bclose

Teclados matriciales

Arduino y los keypads de 4x4

Objetivos

 

 

    • Familiarizarnos con un teclado matricial de 4×4.
    • Usar otra librería externa: KeyPad.
    • Volver a revisar los arrays, esta vez de dos dimensiones.
 

Material requerido.

Imagen de Arduino UNOArduino Uno o similar.Esta sesión acepta cualquier otro modelo de Arduino.
Protoboard conexionesUna Protoboard más cables.
ComponenteUn teclado matricial 4×4
tienda online prometec

Como funciona un teclado matricial

 

Un teclado no es más que una colección de botones, a cada uno de los cuales le asignamos un símbolo o una función determinada. Pero botones al fin y al cabo.

Leer botones es algo que ya no tiene secretos para nosotros, pero si conectáramos cada tecla a un pin digital de nuestro Arduino, pronto estaríamos en apuros.

El teclado de nuestro ordenador suele ser de alrededor de 106 teclas, así que el método de fuerza bruta va a entrar en apuros rápidamente. Necesitamos otra solución.

Y como el mundo está lleno de gente ingeniosa se les ocurrió una solución de lo más elegante, una matriz de teclas.

Vamos a ver un ejemplo con un pequeño teclado numérico de 16 teclas tipo los de los teléfonos móviles o los de los cajeros automáticos.

Esquema de conexiones

Diagrama electrico

 

Para que nuestro Arduino pueda saber que tecla se pulsa, basta con poner tensión en las filas de forma secuencial y luego leer las columnas para ver cuál de ellas tiene HIGH.Los teclados matriciales usan una combinación de filas y columnas para conocer el estado de los botones. Cada tecla es un pulsador conectado a una fila y a una columna. Cuando se pulsa una de las teclas, se cierra una conexión única entre una fila y una columna.

Por ejemplo, ponemos HIGH en la primera fila (hilo 8 en el diagrama de la derecha) y después leemos sucesivamente los hilos correspondientes a las columnas (hilos 4, 3, 2,1). Si ninguno está en HIGH es que no se ha pulsado ninguna tecla de la primera fila.

Pasamos a la segunda fila (hilo 7) y ponemos HIGH, si al leer los hilos 4, 3, 2,1 encontramos que el hilo 1 está en HIGH, es que se ha pulsado la tecla correspondiente a la “B”.

De este modo, para leer un teclado matricial de 4×4 necesitamos 8 hilos en lugar de 16, aunque nos dará un poco más de guerra a la hora de programar. Para un teclado de PC 106 teclas bastaría una matriz de 10×11 o sea 21 hilos en vez de 106.

 

Diagrama de conexión

 

Lo más práctico es conectar el teclado a Arduino directamente, podemos usar cables de protoboard, o bien con un peine de pines para que no se suelte nada.

Teclado matricial 4x4

Esta es otra de esas raras ocasiones en que un esquema electrónico tendría poco sentido, así que pasaremos rápidamente a ver el tema del programa.

 
  • Un apunte rápido: Por comodidad en el diagrama, y porque en los ejemplos que vienen con Arduino utilizan estos mismos números de pines del 0 al 7, los hemos mantenido. Pero conviene saber que Arduino usa los pines 0 y 1 para comunicarse a través del USB, por lo que no es buena usarlos para otra cosa cuando vayamos a usar el puerto serie.
 

El Programa de lectura

 

Como ya dijimos, el programa ha de consistir en ir dando tensión consecutivamente a los pines de las filas 8, 7, 6, 5 y después ir leyendo los valores de las columnas para detectar que teclas se han pulsado.

No es un programa complicado, pero antes de que el pánico se apodere de los que siguen la sesión con creciente temor (y recuerden que tienen algo urgente e ineludible que hacer)  comentaremos que alguien ha tenido este problema antes que nosotros y amablemente ha puesto a nuestra disposición una librería llamada KeyPad ideal para leer este tipo de matrices sin complicaciones,.

 
  • Lo que no quita para que podáis escribir un programa que lea directamente la matriz y reconozcáis las pulsaciones. Animo, no es difícil y el ejercicio siempre es bueno. 
 

Lo primero es descargar la librería e instalarla. La tenéis aquí  Descargar, o bien en la página de Arduino

http://playground.arduino.cc/Code/Keypad#Download

Id a la sección de “Download, install and import” donde encontrareis keypad.zip. Descargadlo y para instalarla recordad que basta con hacer:

Captura de pantalla

En la ventana que sale, buscad el fichero Keypad.zip que habéis descargado, seleccionadlo y listo.

Una vez instalada para usarla basta con que le indiquéis que deseáis usarla. SI hacéis Programa\Importar Librería \ Keypad  veréis que incluye la siguiente línea en vuestro programa:

#include <Keypad.h>

Vamos a ver como usamos esta librería. Lo primero es definir un par de contantes

const byte Filas = 4;          //KeyPad de 4 filas
const byte Cols = 4;           //y 4 columnas

Y ahora una par de arrays para indicarle a la librería que pines de Arduino corresponden a las filas y cuales a las columnas del keypad:

byte Pins_Filas[] = {7, 6, 5, 4};     //Pines Arduino para las filas.
byte Pins_Cols[] = { 3, 2, 1, 0};     // Pines Arduino para las columnas.

Recordad que un array es una colección de elementos que pasamos entre llaves y separados por comas. Es más cómodo que andar definiendo 8 variables.

Recordad lo que vimos en la sesión 9, que cuando definimos una array por enumeración de sus elementos, como en este caso, no necesitamos pasar entre corchetes el número de elementos (Los cuenta el mismo C++ solito).

Tendremos que definirle, además, que símbolos corresponden a cada posición de las teclas. Una nueva oportunidad  para disfrutar de los arrays, pero esta vez de 2 dimensiones en vez de una.

char Teclas [ Filas ][ Cols ] =
    {
        {'1','2','3','A'},
        {'4','5','6','B'},
        {'7','8','9','C'},
        {'*','0','#','D'}
     };
 
  • Definimos el array de 4×4 pasándole las dimensiones entre corchetes. Sus miembros van a ser 4 filas, cada una de las cuales es un array de 4 elementos, y después enumeramos los cuatro arrays de 4 miembros.
  • Fijaros en que cada array va entre llaves. Los elementos de un array se separan por comas, pero al final de las llaves exteriores va un punto y coma porque toda el conjunto es una asignación.
  • Los arrays siempre parecen complicados hasta que te acostumbras pero no es para tanto y este es un buen ejemplo para que comprendéis la idea de un array de 2 dimensiones.
 

Una de las curiosidades de leer una matriz de teclas y después asignar un carácter contenido en un array es que podemos redefinir el valor de las teclas sin más que cambiar el contenido del array.

 
  • Si por lo que sea hubiéramos conectado mal los pines del keypad al Arduino, podríamos redefinir los valores del array para que coincidan con lo que pone en las teclas. Puede ser más fácil que mover de sitio los cables.
  • De hecho es esa capacidad de mapear la representación de un carácter a una posición en una tabla, es lo que permite que podamos reconfigurar el mismo teclado a diferentes lenguas, sin más que cambiar los valores del array (aunque también ayudará mucho luego cambiar los símbolos rotulados en el teclado).
 

Por ultimo tendremos que crear una instancia de Keypad que llamaremos Teclado1

     Keypad Teclado1 = Keypad(makeKeymap(Teclas), Pins_Filas, Pins_Cols, Fils, Cols);

Que leído así asusta, pero que en realidad es una tontería. Traduciendo sería: Crea una instancia del tipo Keypad que llamaras Teclado1 y al que asignarás las teclas que tenemos en el array Teclas, y le decimos que hemos conectado las filas del keypad a los números de pines que te indico en el array Pins_Filas y las columnas al array Pins_Cols.

 
  • MakeKeymap (Teclas) es una función disponible en la librería y que nos permite asignar un array de valores a una matriz. Se hace solo una vez al principio salvo que por lo que sea nos interese cambiarlo sobre la marcha.
 

Por ultimo para leer el keypad hacemos una llamada a otra función de la librería:

char pulsacion = Teclado1.getKey() ;

Por ultimo enviamos a la consola el carácter pulsado. Aquí tenéis el programa en versión completa:Descargar

     #include <Keypad.h>            // Prog_19_1
     const byte Filas = 4;          //Cuatro filas
     const byte Cols = 4;           //Cuatro columnas

     byte Pins_Filas[] = {7, 6, 5, 4};     //Pines Arduino para las filas
     byte Pins_Cols[] = { 3, 2, 1, 0};     // Pines Arduinopara las columnas
     char Teclas [ Filas ][ Cols ] =
          {
              {'1','2','3','A'},
              {'4','5','6','B'},
              {'7','8','9','C'},
              {'*','0','#','D'}
          };
     Keypad Teclado1 = Keypad(makeKeymap(Teclas), Pins_Filas, Pins_Cols, Filas, Cols);
 
     void setup()
        {             Serial.begin(9600) ; }

     void loop()
        {       char pulsacion = Teclado1.getKey() ;
                if (pulsacion != 0)              // Si el valor es 0 es que no se
                    Serial.println(pulsacion);   // se ha pulsado ninguna tecla
        }

Por cierto, en C++ y en otros lenguajes es muy frecuente escribir la instrucción:

if (pulsación != 0)

De esta otra manera (más elegante) completamente equivalente:

if (pulsación )

Porque la condición del if debe evaluarse a TRUE o FALSE y para los ordenadores un 0 es FALSE sin remisión, pero cualquier otro valor que no sea 0 es TRUE, incluyendo un carácter.

 

Resumen de la sesión

 

 

    • Hemos usado nuestro primer keypad hexadecimal
      • Son prácticos y muy sencillos de usar en cuanto le pilléis el tranquillo.
      • Están disponibles en múltiples formatos y tipos, Aquí hemos usado uno típico de 4×4, pero también los hay 4×3 y en diferentes materiales y acabados
      • Un antiguo teléfono móvil roto se puede desmontar y usar su teclado además de otras cosas, y se puede utilizar de la forma que hemos descrito.
    • Hemos usado la excusa del teclado para volver sobre los arrays. Vale la pena de que les dediquéis un poco de tiempo pues os ayudaran a resolver cómodamente más de un problemas de programación, y no se merecen la fama de malotes que tienen.
    • Hemos conocido otra librería externa, KeyPad. Os vendrá muy bien en vuestros proyectos. Más adelante confío en que podamos hacer algún ejemplo más sofisticado con un keypad como hacer que una cierta combinación abra una cerradura de servo por ejemplo.
 

 

 

 

 

(88) Comments

  • Hola queria preguntar como puedo hacer para reconocer el valor de la matriz, por ejemplo el 1×1, es decir el numero 1, y que el arduino responde prendiendo algun led o algo por el estilo

    • Hola Paulo, ya estamos leyendo el teclado y guardamos la tecla que leemos en la variable pulsación. No tienes más que hacer un case y en función de la tecla que se haya pulsado hacer lo que te parezca oportuno. Un saludo.

    • Ademir

    hola,

    he visto varios esquemáticos de conexión de estos teclados y lamentablemente para mi ignorancia, siempre ocupan los mismos pines que las lcd de 20×4 etc, mi duda es imposible conectar un teclado matricial y una lcd 20×4 a la vez?

    • Hola Ademir, puedes usar un LCD que sea I2C.

  • Hola, muy buenas. Me gustaría preguntarte si es posible utilizar esta librería para enviar señales MIDI con ella ya que tengo un teclado casio viejo, de momento ya se cuales son las columnas y las filas y como funciona, solo necesito poder enviar el MIDI pero no se como introducirlo en los arrays.

    • Hola Ismail, puedes utilizar cualquier cosa para enviar las señales. Tenemos algunas sesiones dedicadas al MIDI (muchas menos de las que quisiéramos) que pueden servirte de ayuda: http://www.prometec.net/musica-sonido/

      Un saludo.

  • hola buenas tardes quisiera saber si se puede aplicar una secuencia de codigos y leer si se repite la secuencia marque un indicador que es correcto y si no lo es marque que es incorrecto ,supongamos de inicio presiono 1,2,3,4 y despues oprimo 1,2,4,5 ,marque incorrecto hasta que presione bien el codigo de inicio

Give a Reply

WordPress Anti-Spam by WP-SpamShield