TODOPIC

Microcontroladores PIC => * PROYECTOS * => Mensaje iniciado por: jhoonyn46 en 08 de Marzo de 2009, 00:08:15

Título: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 08 de Marzo de 2009, 00:08:15

buenas noches saluds a todos, estoy estudiando la posibilidad de hacer un conversor de comunicacion quiero hacer la interfaz de un mouse de puerto usb y pasar esa comunicacion a serial asincrona para ser conectada en una pc o en otro equipo q se comunique de esta forma, necesito ayuda en esto cualquiera informacion q me puedan brindar se lo voy agradecer.

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: MLO__ en 08 de Marzo de 2009, 00:57:27

Hola.

No se si te entiendo bien, pero creo que lo que necesitas es una comunicacion USB HID con el descriptor de clase del mouse, es decir que cuando conectes el uC el PC te lo identifique como un mouse?

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 08 de Marzo de 2009, 11:37:00

buenas dias la idea es controlar un mouse usb con un pic 16f628, el pic lo que va hacer es recibir la data enviada por el mouse usb y despues enviarla por el puerto de transmicion rs232, para que llegue a un max 232 y pasar a el protocolo de comunicacion rs232, osea para conectar un mouse usb a el pic y luego de hay la salida al pc pero para q la pc lo vea como un mouse serial

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: MLO__ en 08 de Marzo de 2009, 13:10:04

Hola.

Pues, ese micro no se si te sirva, ya que no tiene hub USB ... no creo que se pueda hacer, ya que el raton se comporta como raton cuando el se comunica con el PC (creo) asi que el uC deberia seguir todo ese protocolo internamente.

No seria mejor hacer el mouse con unos pulsadores y un pot de esos de control de juegos e interfazarlo al PC? de esa manera si podrias usar ese micro.

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: cerebro en 08 de Marzo de 2009, 17:24:16

Copio la info que te dije porque pedi a un moderador que borre el otro hilo..

Citar

hola primero no repitas las preguntas en distintos subforos va contra las reglas del foro si tienes alguna duda de como son estan accesibles a todo el mundo. No te entiendo lo que queres realizar, por lo que comentas lo mejor seria utilizar comunicacion USB HID (con descriptores de mouse), pero el pic que queres utilizar esta lejos de tener implementado ese modulo(aparte no creo que daria la memoria para la comunicacion). Lo que podrias utilizar seria algun CI como el fat232 o el TUSB1106 pero en ese caso la comunicacion cambiaria y no seria mas HID sino "RS232 emulado" (USB CDC). La solucion mas sencilla seria que te pases a la familia 18f que si traen el modulo usb incorporado y el que mas he utilizado personalmente es el 18f2550. Busca en el foro ejemplos que seguro vas a resolver tu problema.
Saludos Smile

pd: pucha esto me recuerda una deuda grande que tengo personal.......

Como bien te explica MLO para establecer el protocolo USB ese micro no esta acondicionado y no he visto por ningun lado que alguien intente emular USB.

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: kain589 en 08 de Marzo de 2009, 18:31:23

Puede que me equivoque, pero ademas el micro deberia funcionar como host ¿no?

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: MLO__ en 08 de Marzo de 2009, 18:34:28

Cita de: MLO__ en 08 de Marzo de 2009, 13:10:04

Pues, ese micro no se si te sirva, ya que no tiene hub USB ... no creo que se pueda hacer, ya que el raton se comporta como raton cuando el se comunica con el PC (creo) asi que el uC deberia seguir todo ese protocolo internamente.

A eso me referia .... yo no creo que se pueda, ya que el raton cuando se conecta al PC, espera una numeracion y otras cosas .... para que el sistema lo detecte como mouse HID.

Insisto: seria mejor hacerse el mouse ...

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 09 de Marzo de 2009, 00:49:23

si pero me mandaron a realizarlo asi con un mouse ps/2 o usb , el problema que me da el ps/2 es q no se como activarlo para q envie trama de comunicacion al pic para poderla transformar en serial , y el pic que me dieron para el diseño es ese , esto un proyecto de la universidad y de verdad no se como hacer para q cualqiera de los 2 mouse se comunique con el pic que tengo. por lo menos el ps/2 si se que se puede con interuccion en el pic ver su trama pero el problema es q no se como hace la computadora para activarlo , porq el teclado no necesita activacion porq ya tengo un programa mas o menos para el y funciona bien. pero con el mouse estoy parado porq no se q hacer. por eso esty pidiendo ayuda

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: MLO__ en 09 de Marzo de 2009, 01:15:10

Hola.

PS2 es mas facil de hacer ... si no estoy mal, el maestro RedPic conecto un teclado ps2 a un pic .... seria algo similar no? voy a revisar el link

EDITO:

Aqui estan:
http://www.todopic.com.ar/foros/index.php?topic=11910.0 (http://www.todopic.com.ar/foros/index.php?topic=11910.0) by RedPic

http://www.todopic.com.ar/foros/index.php?topic=24517.0 (http://www.todopic.com.ar/foros/index.php?topic=24517.0) by suky

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: cerebro en 09 de Marzo de 2009, 01:19:42

aaaaaaaaa paisano ahora si..... ni dudarlo utiliza el ps2 mira este link http://pinouts.ru/Inputs/PS2Mouse_pinout.shtml el problema radica en la aplicacion en la pc mas que nada pero seguramente va a ser el camino mas sencillo. no se que estas manejando....

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 09 de Marzo de 2009, 21:37:03

no el teclado no funciona igual al mouse, el teclado no necesitacodigos de activacion el mouse siy no se cules son ni como hacer para enviarlos a el

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 09 de Marzo de 2009, 21:42:21

lo que me mandan hacer es comunicar el mouse con el pic y ver las trama de comunicacion de sus movimiento y de la pulsacion de los2 botones por el hiper termeinar del pc y despues mas adelante con otro programa en el pic modificarlas tramas ya sea sumandole algo restandole o dividiendo para que me de unas en espesifico que ellos me van a dar, ero lo primero que necesito y mas importante es hacer es comunicar el mouse con el pic 16f628 y el problema esta es que no he podido activarlo porq definitivamente necesita algunos codigode actiacion y tambien como enviarlos al mouse par que el los entienda como que se lo estuviera enviando la pc

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: Suky en 10 de Marzo de 2009, 01:07:16

Fijate aquí, creo que puede servirte con respecto a los códigos que comentas: http://www.computer-engineering.org/ps2mouse/
Con respecto a enviar datos al mouse, yo en mi segundo ejemplo con el teclado ps/2 (http://www.todopic.com.ar/foros/index.php?topic=24517.0) le envio datos al teclado para control de los led's. Como el protocolo es el mismo puede ayudarte. :)

Saludos!!

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: cerebro en 11 de Marzo de 2009, 22:18:06

un aporte de nocturno que puede servirte http://www.micropic.es/index.php?option=com_content&task=view&id=38&Itemid=59

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: PalitroqueZ en 12 de Marzo de 2009, 18:20:49

hay mouses que traen un conector que sirve de adaptador usb->ps-2

ya tienes la interfaz! :)

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 12 de Marzo de 2009, 21:15:27

buenas noche amigo suky estuve viendo su programa y nunca he trabajado en lenguaje emsamblador y no entiendo mucho . yo medio entiendo es lenguaje c pero gracias de todas manera. de verdad esto lo del mouse me tiene emproblemado porq no he podido avanzar en nada con el proyecto porque por mala suerte el no trabaja como el teclado

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: MLO__ en 13 de Marzo de 2009, 01:01:56

Cita de: cerebro en 11 de Marzo de 2009, 22:18:06

un aporte de nocturno que puede servirte http://www.micropic.es/index.php?option=com_content&task=view&id=38&Itemid=59

Eso no da solucion completa a tu problema?

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: Suky en 13 de Marzo de 2009, 01:27:32

Exacto! en ese link esta la solución! :lol:

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 13 de Marzo de 2009, 22:30:18

ya vi el link estoy tratando de adaptarlo a mi pic que el 16f628a y me da error al compilar aqui le envio el progarma para ver si ustedes se dan cuenta de algun detalle que yo no este tomando en cuenta por el que me da ese error , de verdad soy nuevo en la programacion

#include "16F628a.h"
#fuses Hs,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use Delay(Clock=20000000)
#use rs232(baud=4800, xmit=PIN_B2, rcv=PIN_B1, BITS=7)
#zero_ram
#bit INTF_BIT = 0x0B.1 // INTCON BIT 1 = INTF RB0/INT External pt Flag BitInter

/***********************************************************/
/* DEFINICIONES Y DECLARACIONES */
/***********************************************************/

#define RATON_CLOCK PORTBbits.RB0
#define RATON_DATA PORTBbits.RB3
#define TRIS_RATON_CLOCK TRISBbits.TRISB0
#define TRIS_RATON_DATA TRISBbits.TRISB3
#define RATON_FRECUENCIA_CLOCK 13665.0

/***********************************************************/
/* ESTRUCTURAS */
/***********************************************************/

typedef struct {
unsigned BotonIzdo :1;
unsigned BotonDcho :1;
unsigned Botoncentral :1;
unsigned control :1;
unsigned SentidoX :1;
unsigned SentidoY :1;
unsigned OverFlowX :1;
unsigned OverFlowY :1;
} Tipo_byte1_Raton;

typedef struct {
unsigned int X;
unsigned char Y;
unsigned char Ancho;
unsigned char Alto;
unsigned char CodigoEvento;
} TipoObjetos;

/***********************************************************/
/* VARIABLE DE ÀMBITO GLOBAL */
/***********************************************************/

unsigned char HayRaton=0;
char DatosRecibidos[90];
int IndiceDatosRecibidos;
unsigned char BotonIzdo;
unsigned char BotonDcho;
unsigned char BotonCentral;
unsigned char Control;
unsigned char SentidoX;
unsigned char SentidoY;
unsigned char OverFlowX;
unsigned char OverFlowY;
int Raton_CoorX=290;
int Raton_CoorY=189;

Tipo_Byte1_Raton *RATON_Byte1;
TipoObjetos ObjetosActivos[30];
int ObjetosTotales=0;

unsigned char Trigger[]={'T','r','i','g','g','e','r',0};
unsigned char DobleFrecuencia[]={'x','2',0};
unsigned char Pausa[]={'P','a','u','s','a',0};
unsigned char BotonPulsado=0;

void Inializacion(void)
{
unsigned int Channel, PinConfig, Scanselect;

//inicializa el generador de vídeo y borra la pantalla

InicializaVideo();
BorraPantalla;

// envía comandos de inicializacion al ratón
Raton_Inicializa();

// inicializamos la UART para activar interrupción de datos recibidos
InicializaUART();
// dibuja la interface
Boton (Trigger, 220,50,75,16,1);
Boton (DobleFrecuencia, 220,70,26,16,2);
Boton (Pausa, 220,90,60,16,3);
ZonaSensible (18,16,200,160,4);
ZonaSensible (70,200,9,5,10);
ZonaSensible (70,206,9,5,11);
ZonaSensible (80,200,9,5,12);
ZonaSensible (80,206,9,5,13);
ZonaSensible (90,200,9,5,14);
ZonaSensible (90,206,9,5,15);
ZonaSensible (110,200,9,5,16);
ZonaSensible (110,206,9,5,17);
ZonaSensible (120,200,9,5,18);
ZonaSensible (120,206,9,5,19);
ZonaSensible (130,200,9,5,20);
ZonaSensible (130,206,9,5,21);
ZonaSensible (150,200,9,5,22);
ZonaSensible (150,206,9,5,23);
ZonaSensible (160,200,9,5,24);
ZonaSensible (160,206,9,5,25);
ZonaSensible (170,200,9,5,26);
ZonaSensible (170,206,9,5,27);

}

/***********************************************************/
/* Resetea y activa el ratón */
/***********************************************************/

void Raton_Inicializa(void)
{
if (Raton_Conectado())
{
HayRaton=1;
EnviaByte (0xFF); // FF= comando RESET
DelayMs(2);
EnviaByte (0xF4); // F4= comando MOUSEENABLE
DelayMs(2);
EnviaByte (0xE7); // E7= establece la escala a 2:1
DelayMs(2);
EnviaByte (0xE8); // E8= establece la resolución
DelayMs(2);
EnviaByte (0x01); // a 8 count/mm
DelayMs(2);
EnviaByte (0xF3); // F3= establece ratio de muetreo
DelayMs(2);
EnviaByte (0x10); // a 10 muestras/seg.
DelayMs(2);
}
}

/***********************************************************/
/*Comprueba si hay algún ratón conectado esto será si las */
/*líneas CLOCK Y DATA y están a nivel alto */
/***********************************************************/

unsigned char Raton_Conectado ()
{
TRIS_RATON_DATA=1;
TRIS_RATON_CLOCK=1;
return (RATON_CLOCK & RATON_DATA);
}

/***********************************************************/
/* Envía al ratón el dato ByteSalida */
/***********************************************************/

void EnviaByte(unsigned char ByteSalida)
{
int i, Paridad;

TRIS_RATON_DATA=0; // Configuramos como salida las señales del ratón
TRIS_RATON_CLOCK=0;
RATON_CLOCK=0; // bajamos el clock del ratón
DelayUs (168);
RATON_DATA=0; // y al cabo de 100us bajamos DATA
DelayUs (168);
TRIS_RATON_CLOCK=1; // ponemos CLOCK como entrada para recibir los
// pulsos que envíe el ratón
Paridad=255;

EsperoClockBajo(); // bit de start
RATON_DATA=0;
EsperoClockAlto();

for (i=0;i<8;i++) { // para cada bit de datos
EsperoClockBajo(); //esperamos que CLOCK baje para escribir el dato
if ((ByteSalida & (1<<i))>0) // si el bit en cuestión es 1
{
RATON_DATA=1; // SACAMOS UN 1
Paridad =! Paridad; // e invertimos la paridad
}
else
RATON_DATA=0; // en caso contrario sacamos un 0

EsperoClockAlto(); // espero a que el CLOCK suba para enviar
// otro bit o terminar
}
EsperoClockBajo(); // esperamos a que clock baje para escribir
// el bit de paridad

RATON_DATA=Paridad;
EsperoClockAlto();

EsperoClockBajo(); // y volvemos a esperar a que el Clock baje para
// escribir el bit de stop

RATON_DATA=1;

TRIS_RATON_CLOCK=1; // sólo queda "escuchar" al ratón, por lo que
TRIS_RATON_DATA=1; // se ponen como entrads las líneas CLOCK y DATA

EsperoClockAlto();
EsperoDataBajo(); // lo primero que nos envía el ratóm es
// el bit ACK (enterado)
}

/***********************************************************/
/* Espera a que el pulso CLOCK del ratón baje */
/***********************************************************/

void EsperoClockBajo()
{
while (RATON_CLOCK) {};
}

/***********************************************************/
/* Espera a que el pulso CLOCK del ratón suba */
/***********************************************************/

void EsperoClockAlto()
{
while (!RATON_CLOCK) {};
}

/***********************************************************/
/* Espera a que el pulso DATA del ratón baje */
/***********************************************************/

void EsperoDataBajo()
{
while (RATON_DATA) {};
}

/***********************************************************/
/* Inicializa la UART1 a la velocidad del ratón */
/***********************************************************/

void InicializaUART()
{
unsigned int baudvalue;
unsigned int U1MODEvalue;
unsigned int U1STAvalue;

CloseUART1();
/* Configura la interrupción de recepción y no la de transmisión */
ConfigIntUART1(UART_RX_INT_EN & UART_RX_INT_PR7 & UART_TX_INT_DIS );

// baudios = MIPS /(16*(BRG+1)),BRG=-1+ MIPS / (Baudios * 16)
// BRG = -1 + 20.000.000 / (16*11855) = 104.44
baudvalue = (int)(((float)MIPS * 1000.0)/(16.0*RATON_FRECUENCIA_CLOCK))-1;

U1MODEvalue = UART_EN & UART_IDLE_CON & UART_DIS_WAKE & UART_DIS_ABAUD &
UART_DIS_LOOPBACK & UART_ODD_PAR_8BIT & UART_1STOPBIT;

U1STAvalue = UART_INT_TX_EMPTY & UART_TX_PIN_NORMAL & UART_TX_DISABLE &
UART_INT_RX_CHAR & UART_ADR_DETECT_DIS & UART_RX_OVERRUN_CLEAR;

OpenUART1(U1MODEvalue, U1STAvalue, baudvalue);
}

/***********************************************************/
/* Interrupción de recepción UART */
/***********************************************************/

void __attribute__((__interrupt__)) _U1RXInterrupt(void)
{
IFS0bits.U1RXIF = 0; // borra bit señalador de interrupción de recepción

/* lee el buffer de lectura. puede leer más de un carácter */
while( DataRdyUART1())
DatosRecibidos[IndiceDatosRecibidos++]=ReadUART1();

if (U1STAbits.OERR) U1STAbits.OERR==;
}

/***********************************************************/
/* Programa principal */
/***********************************************************/

int main (void)
{
Inicializacion();

while (1)
if (IndiceDatosRecibidos>=3 & HayRaton)
ProcesaMovimientoRaton();
else
VIDEO_SetRatonXY (Raton_CoorX, Raton_CoorY);
return(0);
}

void ProcesaMovimientoRaton()
{
int Cursor,i;
while (IndiceDatosRecibidos>0)
{
RATON_Byte1=&DatosRecibidos[0];
DesplazamientoX=DatosRecibidos[1];
DesplazamientoY=DatosRecibidos[2];

if (RATON_Byte1->Control & !RATON_Byte1->OverflowX &
!RATON_Byte1->OverflowY & !RATON_Byte1->BotonCentral)
{
if (DesplazamientoX) {
if (!Raton_Byte1->SentidoX)
{
Raton_CoorX+=DesplazamientoX;
if (Raton_CoorX>288) Raton_CoorX=288;
}
else
{
Raton_CoorX-=(256-DesplazamientoX);
if (Raton_CoorX<o) Raton_coorX=0;
}
}
if (DesplazamientoY) {
if (RATON_Byte1->SentidoY)
{
Raton_CoorY+=(256-DesplazamientoY);
if (Raton_CoorY>211) Raton_CoorY=211;
}
else
{
Raton_CoorY-=DesplazamientoY;
if (Raton_CoorY<0) Raton_CoorY=0;
}
}
}
cursr=0;
i=0;
while (!Cursor & i<ObjetosTotales)
{
Cursor=(Raton_CoorX>=ObjetosActivos.X &
Raton_CoorX<=ObjetosActivos.X+ObjetosActivos.Ancho-1 &
ObjetosActivos.Alto-1);

if (RATON_Byte1->BotonIzdo)
{
BotonPulsado=1;
HayEvento=ObjetosActivos.CodigoEvento;
}
if (RATON_Byte1->BotonDcho)
{
BotonPulsado=2;
HayEvento=ObjetosActivos.CodigoEvento;
}
i++;
}
VIDEO_PonCursor (Cursor);
VIDEO_PonRatonXY (Raton_CoorX, Raton_CoorY);

IndiceDatosRecibidos-=3;
}
}

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: Suky en 14 de Marzo de 2009, 01:05:04

Las funciones que llamas deben estar definidas anteriormente.
Por ejemplo en Inializacion, las funciones Raton_Inicializa(), InicializaUART(), etc deben estar “arriba” de este código.
Cambia DelayMs() por delay_ms()
DelayUs() por delay_us()

Estas definiciones

Código: C

#define RATON_CLOCK PORTBbits.RB0
#define RATON_DATA PORTBbits.RB3
#define TRIS_RATON_CLOCK TRISBbits.TRISB0
#define TRIS_RATON_DATA TRISBbits.TRISB3

Puedes cámbiarla por:

Código: C

#bit RATON_CLOCK=0x06.0
#bit RATON_DATA=0x06.3
#bit TRIS_RATON_CLOCK=0x86.0
#bit TRIS_RATON_DATA=0x86.3

Dentro de if cambia -> por ==

Hay algunas funciones (InicializaUART, U1RXInterrupt) que son de DsPIC (Yo no las manejo), que seguramente alguien te dirá como migrarlo al PIC16F628A.

Te recomiendo que intentes entender cual es el procedimiento del programa, que funciones cumple cada código, de esa manera se va hacer más fácil buscar errores y/o problemas. Además de modificarlo a tu gusto.

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: Nocturno en 14 de Marzo de 2009, 05:40:21

El programa no puedes compilarlo directamente porque lo hice con un dsPIC y C30. Lo mejor es que lo interpretes y lo asimiles como recomienda Suky, para luego modificarlo o reescribirlo para un PIC16F.

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 14 de Marzo de 2009, 09:53:11

gracias por su ayuda voy a intentar hacerlo. si alguien mas sabe algo como migrar un programa de dispic a pic 16f628 le pido que por favor me ayude

Título: Re: interfaz de mouse usb a serial asincrona
Publicado por: jhoonyn46 en 22 de Marzo de 2009, 22:51:05

buenas ya hice algunos ajuste al programa pero tengo unos problemita el mouse casi no se conecta con el pic y el otro problemita es cuendo logro que se conecte para ver la traa de comunicacion que envia para cada movimiento siempre manda la misma y no se porq , no se si es q estoy recolectado los datos mal o es cuando lo mando a mostrar en pantalla por el puerto serial que no este haciendo bien la rutina para ver todos los datos aqui le envio el programa para que le hecen una ojiadita a ver si me dan otra idea q pueda ser mas efectiva a la que hice yo

//-----------------------------------------------------------------------------
// Title: MOUSE_PC_To_RS232.c
// Description: Interfase entre un MOUSE convencional tipo ps/2 y un puerto RS232
// Date: dic-2008
// Ver.Rev.: V01
// Author: jhonny nuñez (jhonnyn46@gmail.com)
//
//
//------------------------------------------------------------------------------
//
// decode (int) Decodifica la pulsación realizada,
//
// int_ext_isr Rutina de gestión de interrupciones. Captura los diferentes bit's
//
//-----------------------------------------------------------------------------
// RB0 - Señal de reloj
// RB3 - Tren de impulsos (11 bit) Start+10101010+Paridad+Stop
//-----------------------------------------------------------------------------
//
// Commment : Permite conectar un MOUSE PS/2 convencional de PC a un entorno
// gestionado por un PIC 16F628a.
//
//
//
//-----------------------------------------------------------------------------

#include "16F628a.h"
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use Delay(Clock=20000000)
#use rs232(baud=4800, xmit=PIN_B2, rcv=PIN_B1)
#zero_ram
#bit INTF_BIT = 0x0B.1 // INTCON BIT 1 = INTF RB0/INT External pt Flag BitInter

/***********************************************************/
/* DEFINICIONES Y DECLARACIONES */
/***********************************************************/

#bit RATON_CLOCK=0x06.0
#bit RATON_DATA=0x06.3
#bit TRIS_RATON_CLOCK=0x86.0
#bit TRIS_RATON_DATA=0x86.3

int edge, bitcount;
int got_interrupt;
int interrupt_count;
int status_b3;
int data;

/***********************************************************/
/* VARIABLE DE ÀMBITO GLOBAL */
/***********************************************************/

unsigned char HayRaton=0;

/***********************************************************/
/*Comprueba si hay algún ratón conectado esto será si las */
/*líneas CLOCK Y DATA y están a nivel alto */
/***********************************************************/

unsigned char Raton_Conectado ()
{
TRIS_RATON_DATA=1;
TRIS_RATON_CLOCK=1;
return (RATON_CLOCK & RATON_DATA);
}

/***********************************************************/
/* Espera a que el pulso CLOCK del ratón baje */
/***********************************************************/

void EsperoClockBajo()
{
while (RATON_CLOCK) {};
}

/***********************************************************/
/* Espera a que el pulso CLOCK del ratón suba */
/***********************************************************/

void EsperoClockAlto()
{
while (!RATON_CLOCK) {};
}

/***********************************************************/
/* Espera a que el pulso DATA del ratón baje */
/***********************************************************/

void EsperoDataBajo()
{
while (RATON_DATA) {};
}

/***********************************************************/
/* Envía al ratón el dato ByteSalida */
/***********************************************************/

void EnviaByte(unsigned char ByteSalida)
{
int i, Paridad;

TRIS_RATON_DATA=0; // Configuramos como salida las señales del ratón
TRIS_RATON_CLOCK=0;
RATON_CLOCK=0; // bajamos el clock del ratón
delay_us (168);
RATON_DATA=0; // y al cabo de 100us bajamos DATA
delay_us (168);
TRIS_RATON_CLOCK=1; // ponemos CLOCK como entrada para recibir los
// pulsos que envíe el ratón
Paridad=255;

EsperoClockBajo(); // bit de start
RATON_DATA=0;
EsperoClockAlto();

for (i=0;i<8;i++) { // para cada bit de datos
EsperoClockBajo(); //esperamos que CLOCK baje para escribir el dato
if ((ByteSalida & (1<<i))>0) // si el bit en cuestión es 1
{
RATON_DATA=1; // SACAMOS UN 1
Paridad =! Paridad; // e invertimos la paridad
}
else
RATON_DATA=0; // en caso contrario sacamos un 0

EsperoClockAlto(); // espero a que el CLOCK suba para enviar
// otro bit o terminar
}
EsperoClockBajo(); // esperamos a que clock baje para escribir
// el bit de paridad

RATON_DATA=Paridad;
EsperoClockAlto();

EsperoClockBajo(); // y volvemos a esperar a que el Clock baje para
// escribir el bit de stop

RATON_DATA=1;

TRIS_RATON_CLOCK=1; // sólo queda "escuchar" al ratón, por lo que
TRIS_RATON_DATA=1; // se ponen como entrads las líneas CLOCK y DATA

EsperoClockAlto();
EsperoDataBajo(); // lo primero que nos envía el ratóm es
// el bit ACK (enterado)
}

/*****************************************************************************/
/* Rutina de gestión de interrupciones */
/*****************************************************************************/

void decode( int16 sc);
#int_ext

void int_ext_isr(void)

{

//-------- Los bit 3 a 10 se considerran datos. Paridad, start y stop
//-------- son ignorados
if(bitcount < 11 && bitcount > 2)
{
data = (data >> 1);
status_b3 = TRIS_RATON_DATA=1;
if((status_b3) == 1)
{
data = data | 0x80;
}
}
//-------- Todos los bits se han recibido

if(--bitcount == 0)
{
decode(data);
data = 0;
bitcount = 11;
got_interrupt = TRUE;
}
got_interrupt = TRUE;
interrupt_count++;

}

/***********************************************************/
/* Resetea y activa el ratón */
/***********************************************************/

void Raton_Inicializa(void)
{
if (Raton_Conectado())
{

HayRaton=1;

EnviaByte (0xFF); // FF= comando RESET
delay_ms(2);
EnviaByte (0xF4); // F4= comando MOUSEENABLE
delay_ms(2);
EnviaByte (0xE7); // E7= establece la escala a 2:1
delay_ms(2);
EnviaByte (0xE8); // E8= establece la resolución
delay_ms(2);
EnviaByte (0x01); // a 8 count/mm
delay_ms(2);
EnviaByte (0xF3); // F3= establece ratio de muetreo
delay_ms(2);
EnviaByte (0x10); // a 10 muestras/seg.
delay_ms(2);

}
}

void Inializacion(void)
{

// envía comandos de inicializacion al ratón

Raton_Inicializa();

}

/***********************************************************/
/* Programa principal */
/***********************************************************/

void main (void)
{

Inializacion();

//-------- Inicializa las variables usadas por la rutina de interrupción
//-------- antes de activar las interrupciones

interrupt_count = 0;
got_interrupt = FALSE;
status_b3 = 0;

//-------- Desde que se activó el modo PULLUPS del puerto B, el estado
//-------- normal del pin B0 es ALTO. La gestión de la interrupción externa
//-------- se gestiona cuando se produce un cambio de nivel ALTO a BAJO.

ext_int_edge(H_TO_L);

//-------- Asegurarse de que el el bit de flag de la interrupción externa
//-------- es borrado antes de activar la gestión de dicha interrupción
//-------- externa.

INTF_BIT = 0;

enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);

//-------- Bucle principal.
//-------- Chequear si se produce alguna interrupción (got_interrupt). Si es así, contar, borrar
//-------- el flag y esperar 50 ms, reactivando la gestión de las interrupciones

while(1)

{

//-------- Chequear si se produce alguna interrupción (got_interrupt).

if(got_interrupt == TRUE)

{
got_interrupt = FALSE;
INTF_BIT = 0; //-------- Reactivar interrupciones

} // --- End If ---

} // --- End While ---

} // --- End MAIN ---

void decode(int16 sc)

{ // Inicio Decode

putc(0xAA);
putc(sc);
sc= sc >> 8;
putc(sc);
sc= sc >> 8;
putc(sc);
sc= sc >> 8;
putc(sc);
delay_ms(50);
}