Recursos del PIC. Comunicación serie entre dos PICs

[biblioman]

Bueno aquí tenéis el esquema en Proteus de este nuevo ejemplo. He instalado un nuevo plugin en el sitio para que directamente se pueda copiar el código fuente bien formateado desde allí. Si alguien tiene problemas al copiarlo que lo diga y lo pondré aquí. Como siempre espero vuestras aportaciones y mejoras con respecto al ejemplo. No he tenido tiempo de hacer una librería propia en condiciones para el control del teclado. A ver si alguien se anima a crear una con licencia GPL y de esa manera poder compartirla entre todos. Sabiendo ya como sabemos, utilizar el recurso de la interrupción por cambio de estado en RB4-RB7 y sabiendo como conectar el teclado al PIC el realizar el drivers del teclado no es muy complicado, si nadie se anima lo apuntare en tareas pendientes y cuando lo tenga hecho lo compartiré con todos vosotros.

Un saludo

[QuijotescoXp]

Toma y además tocando transmisión de datos (redes). En cada recurso te superas, si señor.
Lástima que hasta el fin de semana no pueda profundizar más en el recurso, pero promete.

Un millón de gracias.

[QuijotescoXp]

Pues sinceramente me ha tentado la idea de hacer el driver del teclado y me voy a poner con ello, aunque no prometo nada aun .
Seguramente que tendré que preguntar algunas cosas que todavía no veo claras, pero esa es mi misión, ser curioso y preguntón.

Saludos y hasta pronto.

[biblioman]

Hola QuijotescoXp. Con respecto al drivers del teclado, cuenta con mi ayuda.

Un saludo

[QuijotescoXp]

Bueno, pues aquí va una primera versión primitiva del driver para teclado matricial 4x4.

Antes de nada quiero comentar algunos aspectos que me parecen relevantes:

- En un primer intento quise hacerlo mediante interrupciones, pero me ha resultado difícil por los motivos siguientes:

Para que el invento funcione se ha de ir secuencialmente activando a 1 los pines RB0 a RB3 y eso se consigue en cada llamada dentro del while al módulo del driver.

La única manera de hacer esto sin espera activa es mediante concurrencia o por interrupciones software, y de por desgracia con eso no contamos.

Se podría intentar resolverlo utilizando la interrupción por desbordamiento del TMR0 para ir activando secuencialmente las líneas anteriores y la interrupción por cambio de estado para controlar que tecla se pulsó, pero esto es algo que deberíamos comentar más despacito.

- Las características de esta primera versión son:

Sólo es válido para el puerto B, por lo tanto hay que tener en cuenta una posible inclusión de resistencias PULLUP.

Se mete un retardo de 30 ms para evitar el problema del rebote en las pulsaciones del teclado. Este parámetro podríamos configurarlo en la llamada a la función de inicio.

Hay que entender que es seguro que es una versión inmensamente mejorable, pero para eso está el foro. A ver si entre todos dejamos un driver al 100%.

Espero que disfruten ustedes tanto como yo haciéndolo.

Código: Seleccionar todo

/******************************************************************************       
*                                                                             *
*  AUTOR      : QuijotescoXp                                                  *
*                                                                             *
*  EMAIL      : lrecuero1@alumno.uned.es                                       *
*                                                                             *
*  WEB        : www.aquihayapuntes.com
*                                                                             *
*  FECHA      : 08/11/09                                                      *
*                                                                             *
*  MICRO      :                                                               *
*                                                                             *
*  FUSES      :                                                               *
*                                                                             *
*  OSC        :                                                               *
*                                                                             *
*  LICENCIA   : GPL                                                           *
*                                                                             *
*  DESCRIPCIÓN: Librería para el manejo de un teclado matricial 4x4.          *
*                                                                             *
******************************************************************************/

#byte port_B = 6
#bit  ROW_3  = 0x06.7  // Identificadores de bits
#bit  ROW_2  = 0x06.6
#bit  ROW_1  = 0x06.5 
#bit  ROW_0  = 0x06.4

/* DEFINICIÓN DE CONSTANTES SIMBÓLICAS ****************************************/
#define COLUMN_0         1
#define COLUMN_1         2
#define COLUMN_2         4
#define COLUMN_3         8
#define NUMBER_COLUMNS   4
#define NUMBER_ROWS      4
#define DEBOUNCER_DELAY 30         

/* DEFINICIÓN DE CONSTANTES ***************************************************/
char const matrixKeyBoard[ NUMBER_ROWS ][ NUMBER_COLUMNS ] =
{
   /* Disposición del teclado */
   '1', '2', '3', 'F',
   '4', '5', '6', 'E',
   '7', '8', '9', 'D',
   'A', '0', 'B', 'C',
};

/* DEFINICIÓN DE VARIABLES LOCALES ********************************************/
static unsigned column;

/* FUNCIONES PÚBLICAS *********************************************************/
void mkd_int( void )
{
   /* Inicialización general */
   set_tris_b( 0xF0 );     /* <RB7:RB4> como entrada, <RB3:RB0> como salida */
   port_B = 0;
   column = 0;     
}

char mkd_keyPress( void )
{         
   static char keyPress = '\0';
   
   /* Se ha de esperar aprox. 30 ms para evitar el rebote del teclado */
   delay_ms( DEBOUNCER_DELAY );   
   
   /* Se comienza activando una columna */
   switch( column )
   {
   case 0:
      /* Se pone a 1 la columna 0 */
      port_B = COLUMN_0;
      break;
   case 1:
      /* Se pone a 1 la columna 1 */
      port_B = COLUMN_1;
      break;
   case 2:
      /* Se pone a 1 la columna 2 */
      port_B = COLUMN_2;
      break;
   case 3:
      /* Se pone a 1 la columna 3 */
      port_B = COLUMN_3;
      break;
   }
   
   /* Se rastrea si hay pulsación en la columna activa */
   if( ROW_0 == 1 )
   {
      keyPress = matrixKeyBoard[ 0 ][ column ];
   }
   else if( ROW_1 == 1 )
   {
      keyPress = matrixKeyBoard[ 1 ][ column ];
   }
   else if( ROW_2 == 1 )
   {
      keyPress = matrixKeyBoard[ 2 ][ column ];
   }
   else if( ROW_3 == 1 )
   {
      keyPress = matrixKeyBoard[ 3 ][ column ];
   }   
   
   if( 3 == column )
   {
      /* Se completo un ciclo, reiniciamos nuevamente */
      column = 0;
   }
   else
   {
      column++;
   }
   
   return( keyPress );
}


También se anexa el DSN y diagrama de flujo de datos de la función principal del driver.
Saludos y hasta pronto.

[biblioman]

Hola QuijotescoXP se nota que te lo has currado. Tú librería me funciona perfectamente en Proteus (aunque habría que probarla en un circuito real), además está perfectamente explicada. Como te dije que contarás con mi ayuda, aquí tienes mi primera aportación a tú librería. He hecho una pequeña modificación en el código para que se pueda utilizar indistintamente en el Puerto B ó D. Aquí va el código.

Código: Seleccionar todo

/*******************************************************************************       
* Modificación Nº1 de la Librería_Teclado 4X4 hecha por QuijotescoXP           *                                                                   *
* LICENCIA   : GPL                                                             *                                                                           *
* DESCRIPCIÓN: Esta modificación permite conectar el tecaldo al puerto B ó al D*         
*                                                                              *   
*******************************************************************************/

//Para usar el puerto B descomenta la siguiente línea

//#define uso_puertoB_teclado4x4 TRUE

#if defined uso_puertoB_teclado4x4
    #byte puerto = 6
    #bit  ROW_3  = 0x06.7  // Identificadores de bits puerto B
    #bit  ROW_2  = 0x06.6
    #bit  ROW_1  = 0x06.5
    #bit  ROW_0  = 0x06.4
   
   
#else
    #byte puerto = 8
    #bit  ROW_3  = 0x08.7  // Identificadores de bits puerto D
    #bit  ROW_2  = 0x08.6
    #bit  ROW_1  = 0x08.5
    #bit  ROW_0  = 0x08.4

#endif


    /* DEFINICIÓN DE CONSTANTES SIMBÓLICAS ****************************************/
    #define COLUMN_0         1
    #define COLUMN_1         2
    #define COLUMN_2         4
    #define COLUMN_3         8
    #define NUMBER_COLUMNS   4
    #define NUMBER_ROWS      4
    #define DEBOUNCER_DELAY 30         

    /* DEFINICIÓN DE CONSTANTES ************************************/
    char const matrixKeyBoard[ NUMBER_ROWS ][ NUMBER_COLUMNS ] =
    {
       /* Disposición del teclado */
       '1', '2', '3', 'F',
       '4', '5', '6', 'E',
       '7', '8', '9', 'D',
       'A', '0', 'B', 'C',
    };

    /* DEFINICIÓN DE VARIABLES LOCALES *******************************/
    static unsigned column;

    /* FUNCIONES PÚBLICAS *******************************************/
    void mkd_int( char x )
    {
       switch( x )
       {
       case 'B':
         set_tris_b( 0xF0 ); /* <RB7:RB4> como entrada, <RB3:RB0> como salida */
         break;
       case 'D':
         set_tris_d( 0xF0);/* <RD7:RD4> como entrada, <RD3:RD0> como salida */
         break;
       }
       puerto = 0;
       column = 0;
       
    }

    char mkd_keyPress( void )
    {         
       static char keyPress = '\0';
       
       /* Se ha de esperar aprox. 30 ms para evitar el rebote del teclado */
       delay_ms( DEBOUNCER_DELAY );   
       
       /* Se comienza activando una columna */
       switch( column )
       {
       case 0:
          /* Se pone a 1 la columna 0 */
          puerto = COLUMN_0;
          break;
       case 1:
          /* Se pone a 1 la columna 1 */
          puerto = COLUMN_1;
          break;
       case 2:
          /* Se pone a 1 la columna 2 */
          puerto = COLUMN_2;
          break;
       case 3:
          /* Se pone a 1 la columna 3 */
          puerto = COLUMN_3;
          break;
       }
       
       /* Se rastrea si hay pulsación en la columna activa */
       if( ROW_0 == 1 )
       {
          keyPress = matrixKeyBoard[ 0 ][ column ];
       }
       else if( ROW_1 == 1 )
       {
          keyPress = matrixKeyBoard[ 1 ][ column ];
       }
       else if( ROW_2 == 1 )
       {
          keyPress = matrixKeyBoard[ 2 ][ column ];
       }
       else if( ROW_3 == 1 )
       {
          keyPress = matrixKeyBoard[ 3 ][ column ];
       }   
       
       if( 3 == column )
       {
          /* Se completo un ciclo, reiniciamos nuevamente */
          column = 0;
       }
       else
       {
          column++;
       }
       
       return( keyPress );
    }


Programa principal:

Código: Seleccionar todo

/*--------------------------------------------------------*\
|  Comunicación entre dos PIC's por USART. Transmisor     |               
|  autor: biblioman                                       |
|  www.aquihayapuntes.com                                 |
\*--------------------------------------------------------*/

#include <16F877.h>
#use delay (clock = 4000000)

#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG


#use rs232(uart1, baud=9600)//usart1 -->ajuste de XMIT y RCV para la USART 1

#include "Libreria_Teclado4X4.c"
void main() {
   char c;
  //mkd_int('B'); //inizializo drivers teclado para puerto B
   mkd_int ('D'); //inicializo drivers teclado para puerto D
   while(true)
  {
     c = mkd_keyPress();
     if(c != 0 )//si se ha pulsado una tecla
     {
        putc(c);//Envía el caracter vía serie por la USART del PIC
     
     }

  }   

}



Algunos comentarios constructivos:

Sólo es válido para el puerto B, por lo tanto hay que tener en cuenta una posible inclusión de resistencias PULLUP.

Efectivamente si incluimos las PULLUP del puerto B, se tiene que tener en cuenta en la lógica del programa, como te habrás dado cuenta, no basta con poner la instrucción:

port_b_pullups(true);

Se mete un retardo de 30 ms para evitar el problema del rebote en las pulsaciones del teclado. Este parámetro podríamos configurarlo en la llamada a la función de inicio.

Lo de meter el retardo como un parámetro, me parece bien. Pero el problema lo veo en el propio retardo, es decir, al no utilizar interrupciones , si no se pulsa ninguna tecla el programa no hará nada, pero estaremos desperdiciando 30 ms de tiempo de procesador en cada ciclo while, que no podremos emplear en hacer otras cosas. Habría que ver en que circuitos podría ser esto una limitación.

En conclusión, como te he dicho al principio se nota que te lo has currado, enhorabuena.
Un saludo y hasta la próxima.
El DNS para el puerto D lo tienes aquí

[QuijotescoXp]

Me alegro de que te guste y grácias por la nueva aportación. Yo también he vuelto a aportar algo más a tu idea con el fin de hacerlo un poco más genérico, haciendo uso de la potencia que nos ofrecen las macros en C.

Luego me cuentas que te parece esta pequeña modificación que he hecho.

Quedo a la espera de nuevas ordenes.

Saludos y hasta pornto.

Código: Seleccionar todo

/******************************************************************************       
*                                                                             *
*  AUTOR      : QuijotescoXp                                                  *
*                                                                             *
*  EMAIL      : lrecueo1@alumno.uned.es                                       *
*                                                                             *
*  WEB        : www.aquihayapuntes.com                                        *
*                                                                             *
*  FECHA      : 08/11/09                                                      *
*                                                                             *
*  VERSIÓN    : 1.2                                                           *
*                                                                             *
*  LICENCIA   : GPL                                                           *
*                                                                             *
*  DESCRIPCIÓN: Librería para el manejo de un teclado matricial 4x4.          *
*                                                                             *
*  REVISIONES : ( 08/11/09 por Biblioman ) Se añade la posibilidad utilizar   *
*                                                                             *
*               indistintamente el Puerto B o D.                              *
*                                                                             *
******************************************************************************/
// Para el uso del puerto B se descomenta la siguiente línea
//#define use_port_B TRUE

#if defined use_port_B
    #byte port   = 6
    #bit  ROW_3  = 0x06.7  // Identificadores de bits puerto B
    #bit  ROW_2  = 0x06.6
    #bit  ROW_1  = 0x06.5
    #bit  ROW_0  = 0x06.4   
#else
    #byte port   = 8
    #bit  ROW_3  = 0x08.7  // Identificadores de bits puerto D
    #bit  ROW_2  = 0x08.6
    #bit  ROW_1  = 0x08.5
    #bit  ROW_0  = 0x08.4
#endif

#if defined use_port_B
    #define set_tris_port( x ) ( set_tris_b( x ) )
#else
    #define set_tris_port( x ) ( set_tris_d( x ) )
#endif

/* DEFINICIÓN DE CONSTANTES SIMBÓLICAS ****************************************/
#define COLUMN_0         1
#define COLUMN_1         2
#define COLUMN_2         4
#define COLUMN_3         8
#define NUMBER_COLUMNS   4
#define NUMBER_ROWS      4
#define DEBOUNCER_DELAY 30         

/* DEFINICIÓN DE CONSTANTES ************************************/
char const matrixKeyBoard[ NUMBER_ROWS ][ NUMBER_COLUMNS ] =
{
    /* Disposición del teclado */
    '1', '2', '3', 'F',
    '4', '5', '6', 'E',
    '7', '8', '9', 'D',
    'A', '0', 'B', 'C',
};

/* DEFINICIÓN DE VARIABLES LOCALES *******************************/
static unsigned column;

/* FUNCIONES PÚBLICAS *******************************************/
void mkd_int( void )
{
   set_tris_port( 0xF0 ); /* 4 MSB como entrada, 4 LSB como salida */
   port   = 0;
   column = 0;   
}

char mkd_keyPress( void )
{         
    static char keyPress = '\0';
   
    /* Se ha de esperar aprox. 30 ms para evitar el rebote del teclado */
    delay_ms( DEBOUNCER_DELAY );   
   
    /* Se comienza activando una columna */
    switch( column )
    {
    case 0:
       /* Se pone a 1 la columna 0 */
       port = COLUMN_0;
       break;
    case 1:
       /* Se pone a 1 la columna 1 */
       port = COLUMN_1;
       break;
    case 2:
       /* Se pone a 1 la columna 2 */
       port = COLUMN_2;
       break;
    case 3:
       /* Se pone a 1 la columna 3 */
       port = COLUMN_3;
       break;
    }
   
    /* Se rastrea si hay pulsación en la columna activa */
    if( ROW_0 == 1 )
    {
       keyPress = matrixKeyBoard[ 0 ][ column ];
    }
    else if( ROW_1 == 1 )
    {
       keyPress = matrixKeyBoard[ 1 ][ column ];
    }
    else if( ROW_2 == 1 )
    {
       keyPress = matrixKeyBoard[ 2 ][ column ];
    }
    else if( ROW_3 == 1 )
    {
       keyPress = matrixKeyBoard[ 3 ][ column ];
    }   
   
    if( 3 == column )
    {
       /* Se completo un ciclo, reiniciamos nuevamente */
       column = 0;
    }
    else
    {
       column++;
    }
   
    return( keyPress );
}


[biblioman]

OK. Estoy viendo una manera diferente de controlar el teclado 4X4, utilizando solo cuatro líneas de conexión, no digo más por que no se si lo podré implementar en Proteus, aunque ando un poco liado, a ver si lo tengo listo en lo que va de semana.
Un saludo.

[myesid]

hola Biblioman: pido tu ayuda ya que no se como arreglar este problema

tengo un programa transmisor que es el siguiente

Código: Seleccionar todo

#include <16F628A.h>
   #use delay (clock=4000000)
   #use rs232(baud=9600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)

   #byte porta=0x05
   #use fast_io(a)
   
   #byte portb=0x06
   #use fast_io(b)
   
void main(void)
{
      int dato;
   while(true)
   {
      dato=12;
      putc(dato);
      printf("dato enviado%u\r",dato);
      delay_ms(1000);
//!      dato=0;
//!      putc(dato);
//!      printf("dato enviado%u\r",dato);
//!      delay_ms(1000);
//!      dato=2;
//!      putc(dato);
//!      printf("dato enviado%u\r",dato);
//!      delay_ms(1000);
   }

}



y quiero que el receptor reciba este dato de la siguiente forma

Código: Seleccionar todo

    #include <16F628A.h>
    #use delay (clock=4000000)
    #use rs232(baud=9600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)

   
    // declaracion de puertos direccion en mapa de memoria
    #byte porta=0x05
    #use fast_io(a)
   //al usar bit a bit como salida se debe declarar el tris correspondiente en el main     
    #byte portb=0x06
    #bit valvula=0x06.7
    #use fast_io(b)
     
     
     
    //declaracion de variables globales
    // declaracion de variables
         int eepromv [3];// valor de la eeprom
           int datonwgrab=1;
         //int datonwgrab[3]={1,4,5};     

   
//!
    #int_rda
    void rda_isr()//función de interrupción por recepción de datos USART             
    {
      valvula=0;   
      datonwgrab=getc();
      printf("el dato es%u\r",datonwgrab);
      write_eeprom(0,datonwgrab);
      //delay_ms(1000);
//!      datonwgrab[0]=getc();
//!      write_eeprom(0,datonwgrab[0]);
//!      delay_ms(1000);
//!      datonwgrab[1]=getc();
//!      write_eeprom(1,datonwgrab[1]);
//!      delay_ms(1000);
//!      datonwgrab[2]=getc();
//!      write_eeprom(2,datonwgrab[2]);
//!      delay_ms(1000);
//!
     
    }


     
    void main(void)
    {
       
         // guarda el numero del decodificador en la eeprom interna del pic
            write_eeprom(0,0);
            write_eeprom(0,datonwgrab);
//!            write_eeprom(0,datonwgrab[0]);
//!            write_eeprom(1,datonwgrab[1]);
//!            write_eeprom(2,datonwgrab[2]);
           
            eepromv[0]=read_eeprom(0);
            eepromv[1]=read_eeprom(1);
            eepromv[2]=read_eeprom(2);
 
         
         //configuracion de puertos
         set_tris_b(0x0f);
         enable_interrupts(global);         
         enable_interrupts(int_rda);
       
       
           
         valvula=0;         
         //programa
         while(true);         
    }             


pero lo que me sucede es que al enviar el dato primero no lo recibe y segundo no lo almacena en la eeprom del pic receptor, cuando trato de yo mismo a travez del virtual insertar un valor como por ejemplo el 1 me sale guardado en la eeprom del recptor un 31, no se que es lo que sucede.

por favor echale un ojo al codigo y comentame cual es el error que yo por mas que le hago no lo encuentro y ademas ya me desespero demasiado este problema no se me ocurre nada mas.

saludos y con mucha rabia por no poder sacar a delante este codigo
Myesid

[biblioman]

Hola myesid. Por lo que veo, tú equivocación es como estas enviando los datos y la interpretación que haces de ellos en el
receptor.
La función putc() envía por el puerto serie un caracter ó una cadena de caracteres, pero no le puedes pasar un número entero. Al igual que la función: getc() lo que espera que le llegue por el puerto serie RS232 es otro caracter.

Otra cosa que tienes que tener en cuenta es que los caracteres están codificados en código ASCII, y el caracter '1' no
corresponde con el número hexadecimal 1, sino con el 31, mira la tabla ASCII y comprúebalo.
Por tanto, para almacenar dos caracteres necesitarás dos posiciones de memoria y no una.

Mira el siguiente ejemplo, que almacena dos caracteres en la EEPROM del receptor:

TRANSMISOR

Código: Seleccionar todo

#include <16F628A.h>
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOMCLR, NOLVP, NOCPD
#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8)


void main()
{
     char dato1='1';
     char dato2='2';   
     putc(dato1);
     putc(dato2);
   
}


RECEPTOR

Código: Seleccionar todo

#include <16F628A.h>
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOMCLR, NOLVP, NOCPD
#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8)

//declaracion de variables globales
int contador=0;


#int_RDA
void  RDA_isr(void)
{
   char cdecenas,cunidades;
 
  if (contador ==0)
  {   
      cdecenas=getch(); 
      write_eeprom(0,cdecenas);
      contador++;
  }
     else
     {
      cunidades=getch();
      write_eeprom(1,cunidades);
     
     }
     
     
}



void main()
{

   
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);

}


Y aquí tienes una imagen del circuito simulado:



Mira este post también, por si te sirve de ayuda:

http://www.aquihayapuntes.com/foro/viewtopic.php?f=11&t=40&start=0&sid=07af6d07cfe200e908181b6793733e0e

Un saludo