TECLADO MATRICIAL 4x4 Los teclados matriciales son muy utilizados en sistemas embebidos, ya que ofrecen el control de varias teclas tecl as utilizando solo un puerto del microcontrolador.
Tabla de Contenido ________________________________________________________________________________
DEFINICIÓN
FUNCIONAMIENTO
PROGRAMACIÓN
LISTA DE PARTES
ENSAMBLE
DEFINICIÓN Un teclado matricial es un simple arreglo de botones conectados en filas y columnas, de modo que se pueden leer varios botones con el mínimo número de entradas requeridas. Un teclado matricial 4×4 solamente ocupa 4 líneas de un puerto para las filas y otras 4 líneas para las columnas, de este modo se pueden leer 16 teclas utilizando solamente 8 entradas (un solo puerto) de un microcontrolador.
Este dispositivo, contiene varias teclas, las cuales sirven para introducir datos, por ejemplo a un microcontrolador, que realiza la función de calculadora, marcador telefónico, cerradura electrónica y una infinidad de aplicaciones.
FUNCIONAMIENTO La mayoría de los teclados se leen por una técnica de exploración consistente en ir leyendo consecutivamente las filas o las columnas de éste. Hay circuitos especializados en esta tarea, pero es fácil hacer que un microcontrolador lea estos teclados matriciales
La figura muestra un teclado matricial de 4x4, el cual tiene 16 teclas, las cuales están configuradas en cuatro renglones y cuatro columnas. Para la configuración del teclado matricial en el microcontrolador se utiliza algunos de sus puertos en el cual cuatro bits del puerto funcionan como salida y los cuatro bits restantes funcionan como entrada. El funcionamiento básico del teclado matricial consiste en rastrear la unión entre un renglón y una columna, mediante un algoritmo que descifra cual tecla fue presionada.
En este caso configuraremos nuestro teclado matricial de la siguiente manera: 1.
2.
Utilizaremos el puerto A del microcontrolador para la conexión del teclado: •
Los cuatro bits menos significativos estarán conectados a los renglones (PA0-PA3).
•
Los cuatro bits más significativos estarán conectadas a las columnas (PA4- PA7).
•
No es necesario activar las resistencias de pull-up internas del microcontrolador.
El puerto B del microcontrolador (PB0–PB7) estará configurado como salida, donde se conectara un display cátodo de 7 segmentos, el cual mostrara el número de la tecla oprimida.
Tareas básicas que realiza un programa de teclado matricial
Inicio
Mediante el software se hace un recorrido en los cuatro renglones de nuestro teclado, mientras que ninguna tecla sea presionada el valor lógico de estas se mantienen en un 1.
Se presionó alguna tecla? NO
SI Cuando se detecte un valor distinto a un 1, se hace un rastreo de los renglones mediante la comparación de en qué renglón se detectó el
Rastrear renglones para encontrar columna de la tecla oprimida.
cero, además de aplicar el algoritmo de sumar el
número
de
la
columna
para
saber
exactamente que botón fue presionado.
Es importante recordar que en la práctica existe
Descifrar la tecla oprimida.
un efecto de rebote al presionar una tecla, para resolver este problema basta que en el programa se le aplique un pequeño retardo “_delay_ms(time ms)”, dependiendo de la aplicación es el tiempo que pondremos de retardo, generalmente es de 200ms.
PROGRAMACIÓN Para comenzar con la programación del ATMega16 comenzaremos con declarar las librerías necesarias para el funcionamiento del teclado matricial. #include
// Librería principal para utilizar los puertos del Microcontrolador #include // Librería necesaria para utilizar memoria flash del microcontrolador
Este programa en específico utiliza la memoria flash del microcontrolador para guardar los números que se mostraran en el display de siete segmentos. También es necesario declarar el prototipo de la función del teclado matricial y la secuencia que se utilizara para el recorrido de los renglones del mismo. //Números Almacenados en la memoria Flash del microcontrolador const char tabla[] PROGMEM = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F,0x67,0x77,0x7C,0x39,0x5E,0x79, 0x71}; // Secuencia de barrido de reglones en el teclado matricial volatile unsigned char secuencia[] = {0xFE, 0xFD, 0xFB, 0xF7}; // Prototipo de la función teclado. unsigned char teclado();
Ahora comenzamos con el cuerpo del programa, en donde se configuraran algunos puertos del microcontrolador como entradas y salidas, además de declarar algunas variables útiles en el proceso de ejecución del mismo. int main() { unsigned char tecla=0; // Utilizamos el puerto A del microcontrolador para conectar el teclado. DDRA = 0x0F; // Los 4 bits menos significativos funcionan como salida y los demás como entradas DDRB = 0xFF; // Se configuran los 8 bits del puerto B como salida // Ciclo infinito, para la ejecución continua del programa en el microcontrolador while(1) { tecla=teclado(); // Se llama a la función del teclado y recibimos en la variable tecla. if (tecla != 0xFF) // Verificamos si se ha presionado una tecla PORTB=pgm_read_byte(&tabla[tecla]); // Se muestra en display la tecla presionada } }
Por ultimo escribimos la función del teclado, en la cual viene el algoritmo de detección de tecla, donde solo se realiza un recorrido de los renglones con la secuencia de barrido escrita
anteriormente en el código y se suma el número de la columna al renglón donde fue presionada la tecla. unsigned char teclado(){ // Función para el teclado matricial unsigned char renglon, j, dato; for (renglon=0, j=0; j<4; j++){ // Recorrido de los renglones del teclado PORTA = secuencia [j]; asm("nop"); dato = PINA & 0xF0; if(dato != 0xF0){ switch (dato){ // Se rastrea el renglón y se le suma el numero de columna case case case case }
0xE0: 0xD0: 0xB0: 0x70:
return return return return
renglon; (renglon + 1); (renglon + 2); (renglon + 3);
} renglon = renglon + 4; } return 0xFF; // Se envia unos si no se presiona ninguna tecla
Tu programa debe verse de la siguiente manera, solo resta compilar el código, si este no presenta ningún error el compilador automáticamente generara un archivo con la extensión “.hex”, el cual es el archivo que vas a cargar a tu microcontrolador. #define F_CPU 1000000UL #include #include const char tabla[] PROGMEM = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F,0x67,0x77,0x7C,0x39,0x5E,0x79, 0x71}; volatile unsigned char secuencia[] = {0xFE, 0xFD, 0xFB, 0xF7}; unsigned char teclado(); int main() { unsigned char tecla=0; DDRA = 0x0F; DDRB = 0xFF;
while(1) { tecla=teclado(); if (tecla != 0xFF) PORTB=pgm_read_byte(&tabla[tecla]); } } unsigned char teclado(){ unsigned char renglon, j, dato; for (renglon=0, j=0; j<4; j++){ PORTA = secuencia [j]; asm("nop"); dato = PINA & 0xF0; if(dato != 0xF0){ switch (dato){ case 0xE0: return case 0xD0: return case 0xB0: return case 0x70: return } } renglon = renglon + 4; } return 0xFF; }
renglon; (renglon + 1); (renglon + 2); (renglon + 3);
LISTA DE PARTES JP6
Tira de 5 terminales doble
R108 - R111 330 Ω (naranja-naranja-café) S10 - S25
Push button
PCB
Tarjeta de cobre
ENSAMBLE Para ensamblar el teclado matricial identifique cada uno de los componentes, colóquelos y suéldelos en la tabla de cobre (PCB) como lo indica las figuras impresas en él. Primero coloque los puentes marcados en la tarjeta de cobre antes de colocar los botones. Recomendamos emparejar los pines de los botones antes de instalarlos para una mejor inserción.
