interfaz de mouse usb a serial asincrona

[jhoonyn46]

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

[MLO__]

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?

[Suky]

Exacto! en ese link esta la solución! 

[jhoonyn46]

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;
    }
}
 

[Suky]

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

1. #define RATON_CLOCK PORTBbits.RB0
2. #define RATON_DATA PORTBbits.RB3
3. #define TRIS_RATON_CLOCK TRISBbits.TRISB0
4. #define TRIS_RATON_DATA TRISBbits.TRISB3

Puedes cámbiarla por:

Código: C

1. #bit RATON_CLOCK=0x06.0
2. #bit RATON_DATA=0x06.3
3. #bit TRIS_RATON_CLOCK=0x86.0
4. #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.

[Nocturno]

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.

[jhoonyn46]

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

[jhoonyn46]

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);
}