Siguenos en ...

Google+facebooktwitter

youtubepinterest RSS aquihayapuntes

Últimos Tutoriales


Licencia

Creative Commons

 

Todo el contenido de este sitio está bajo una licencia de Creative Commons

 

Control de un teclado 4X4 con el codificador MM74C922

Otra forma de controlar un teclado a través de un PIC es con la ayuda del codificador MM74C922. El datasheet del componente lo tenéis aquí.

 

Con este dispositivo se puede controlar fácilmente y sin necesidad de ninguna librería un teclado 4X4, ampliable fácilmente a 2 teclados 4X4.

 

Básicamente el circuito consta de ocho entradas (x1 a x4, y1 a y4), donde conectaremos las cuatro filas y columnas del teclado. La salida en función de la tecla pulsada la tendremos en formato binario en las patillas A, B, C y D. Si miráis el esquema de bloques del componente, veréis que estas salidas van a través de unas básculas tipo D que hacen de memoria, con lo que el valor de la tecla pulsada se mantiene hasta que se pulsa otra y sobrescribe el antiguo valor.

Además dispone de una salida (DA) que se pone a nivel alto cada vez que se pulsa una tecla (ideal para el empleo de interrupciones).

 

Otra ventaja de este componente electrónico es que está modelado en Proteus, con lo que podemos simular su funcionamiento junto con un Microcontrolador.

 

El ejemplo ya hecho del display quedaría de la siguiente manera:

Circuito control teclado 4X4 con el codificador MM74C922

 

El valor de la tecla pulsada lo leeremos a través de las patillas RB4-RB7 y la salida DA la conectaremos a la patilla RB0/INT, para emplear la interrupción por entrada de pulso externo.

 

Si en vez de interrupciones utilizamos el sistema “polling”, es decir la comprobación constante del estado de las patillas (RB4-RB7) a través de un bucle infinito dentro de la función principal ó de otra cualquiera, con cuatro líneas serían suficientes para el control del teclado.

 

El código fuente del microcontrolador sería el siguiente:

 

/*-----------------------------------------------------------*\ 
|  Control de un teclado 4X4 con con el codificador MM74C922 | 
|  autor: biblioman                                          | 
|  www.aquihayapuntes.com                                    | 
\*-----------------------------------------------------------*/ 
 
#include <16F877.h> 
//Configuración de los fusibles. 
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG 
#use delay(clock=4000000) //Frecuencia de reloj 4MHz 
#byte  puerto_B = 0x06    // Identificador para el puerto B. 
#byte  puerto_D = 0x08    // Identificador para el puerto C. 
 
#int_EXT 
void  EXT_isr(void){  
 
 switch( puerto_B & 0xF0 ) 
 { 
 
 case 0x20: 
 puerto_D = 0x3F; //0 
 break; 
 case 0xF0: 
 puerto_D = 0x06; //1 
 break; 
 case 0xE0: 
 puerto_D = 0x5B; //2  
 break;  
 case 0xD0: 
 puerto_D = 0x4F; //3 
 break; 
 case 0xB0: 
 puerto_D = 0x66;  //4  
 break; 
 case 0xA0: 
 puerto_D = 0x6D;//5 
 break; 
 case 0x90: 
 puerto_D = 0x7D; //6 
 break; 
 case 0x70: 
 puerto_D = 0x07;//7 
 break; 
 case 0x60: 
 puerto_D = 0x7F; //8 
 break; 
 case 0x50: 
 puerto_D = 0x6F; //9 
 break; 
 case 0x30: 
 puerto_D = 0xF7; //A 
 break; 
 case 0x10: 
 puerto_D = 0x7C; //b 
 break; 
 case 0x00: 
 puerto_D = 0x58; //c 
 break; 
 case 0x40: 
 puerto_D = 0x5E; //d 
 break; 
 case 0x80: 
 puerto_D = 0x79; //E 
 break; 
 case 0xC0: 
 puerto_D = 0x71; //F 
 break; 
 
 default: 
 
 break; 
 }  
 
} 
 
void main() 
{ 
 set_tris_b(0xFF); //Puerto B como entrada 
 set_tris_d( 0x80 );//RD6-RD0 -->como salida, RD7--> Entrada (No utilizado) 
 
 enable_interrupts(GLOBAL);//habilito interrupción global 
 enable_interrupts(INT_EXT);//habilito interrupción externa 
 
 
 
 puerto_D =0x80; //inicializo puerto D (RD6-RD0=0) 
 
 while(True) 
 { 
 //código principal 
 
 } 
 
} 

 

Comentario

El código empleado ya está más que comentado de los ejemplos anteriores, por lo que creo que no es necesario volver comentarlo. Solo hacer una pequeña anotación al respecto: dependiendo de cómo se conecten las filas y columnas del teclado al codificador MM74C922 se tendrá una combinación de valores a la salida diferente, en función del código que queramos emplear en el teclado. Lo más fácil es que conectéis el teclado al codificador como queráis y simuléis el circuito en Proteus antes de conectar el microcontrolador y hagáis una tabla de verdad con los valores de la salida en función de la tecla pulsada.

 

Para el ejemplo de figura la tabla sería la siguiente:

 

 

TeclaSalida MM74C922
0
0x20
1
0xF0
2
0xE0
3
0xD0
4
0xB0
5
0xA0
6
0x90
7
0x70
8
0x60
9
0x50
A
0x30
b
0x10
c
0x00
d
0x40
E
0x80
F
0xC0

 

Ventajas y desventajas del uso de este componente para el control de teclados

Bajo mi punto de vista, estas son las ventajas y desventajas de utilizar este componente para controlar la salida de un teclado junto a un microcontrolador:

 

Desventajas:

  • la desventaja yo creo que es clara y es el tener que incluir más componentes al circuito para hacer una cosa, que se puede implementar por software. Aunque estos componentes son muy baratos y se pueden conseguir fácilmente por Internet, el tamaño de la placa inevitablemente tendrá que ser un poco más grande.

Ventajas:

  • No se necesita ninguna librería externa para controlar el teclado.
  • El .HEX generado al compilar es más pequeño, por lo que dispondremos de más memoria de programa en el PIC.
  • Fácil implementación del código a través de interrupciones.
  • Posibilidad de ampliar el teclado a uno de 32 teclas, (en el datasheet viene el esquema de cómo hacerlo).
  • Utilización de menos patillas en el PIC, se puede controlar un teclado de 32 teclas con solo cinco pines del PIC.

 

En fin un componente que no sustituye a la librería convencional, pero que en determinados circuitos será interesante tener en cuenta.

 

El DNS del circuito lo tenéis aquí

 

Como siempre espero vuestros comentarios al respecto en el foro.

 

Un saludo

 

© 2007-2017 AquiHayapuntes.com