Teclado matricial 4×4 con Arduino
El uso de un teclado matricial 4×4 con Arduino es muy común en varios proyectos con Arduino, estos teclados son muy útiles cuando deseamos controlar dispositivos actuadores mediante alguna combinación de teclas, como por ejemplo abrir una cerradura mediante una contraseña, cambiar la velocidad de un motor mediante un menú accionado por el teclado matricial con Arduino, el típico proyecto de una calculadora con Arduino, etc., el uso de estos teclados en proyectos de Arduino son básicamente infinitas.
En el mundo de la electrónica existe una gran infinidad de teclados que podemos emplear en varios proyectos con Arduino, los más comunes son los teclados matriciales 4×4 y 3×4, pero existen básicamente de cualquier configuración, además podemos realizar nuestros propios teclados matriciales, ya que estos teclados solo están compuestos por varios pulsadores y resistencias interconectados entre sí de manera matricial.
Para manejar estos teclados matriciales 4×4 en Arduino se requiere generalmente 8 hilos de conexión y podremos manejar 16 pulsadores, si el teclado matricial es de 3×4 necesitaremos 7 hilos y podremos manejar hasta 12 pulsadores, también podemos manejar estos teclados matriciales con muchos menos hilos de conexión, incluso se puede manejar con un solo hilo de conexión, esto se logra haciendo un divisor de voltaje y asignándole un voltaje pequeño para cada pulsador, este método es muy sencillo y se presentara un ejemplo práctico en próximos artículos.
¿Cómo funciona un teclado matricial con Arduino?
Estos teclados matriciales generalmente están conformados por filas y columnas, si nuestro teclado matricial a usar en Arduino es de 4×4 tendremos 4 filas y 4 columnas interconectadas entre si y si cada intersección representaría un pulsador tendríamos 16 pulsadores interconectados entre sí, para acceder a alguna de estas intersecciones tendremos que identificarlos de alguna manera, por ejemplo si quisiéramos identificar el pulsador conectado en la primera fila y en la segunda columna esto lo podemos lograr poniendo la primera fila a 1 lógico y la segunda fila a un 0 lógico al presionar el pulsador enviara 1 lógico de la fila hacia la columna esto nos daría la certeza para saber que pulsador fue presionado, y gracias a esto nos permite detectar cualquier tecla que se haya pulsado en la matriz de pulsadores.
Disposición de pines de un teclado matricial 4×4
Los teclados matriciales flexibles 4×4 usados para proyectos con Arduino tienen 8 pines donde los 4 primeros son las filas y los 4 restantes son las columnas.
Librería para manejar teclados matriciales en Arduino
Controlar teclados matriciales en Arduino son relativamente sencillas, si se tiene conocimiento amplio sobre programación se la puede manejar sin la necesidad de ninguna librería realizando nuestras propias funciones para tener un control total de estos teclados matriciales, en caso que no se tenga estos conocimientos sobre programación ya existe múltiples librerías para manejar estos teclados matriciales en Arduino, una de las más usadas es la librería “keypad.h” que la podemos instalar directamente desde el IDE de Arduino, accediendo desde el menú a Herramientas >> Administrar Bibliotecas >> [Buscar keypad]
Uso de la librería <keypad.h> para manejar teclados matriciales en Arduino
Esta librería ya tiene varias funciones programadas, pero antes de usarla debemos incluirla a nuestro código escribiendo la siguiente instrucción #include <keypad.h> en la cabecera, además se debe incluir de una serie de instrucciones que se detallan a continuación:
#include <keypad.h>Configuramos el número de filas y columnas
Debemos definir el numero de filas y columnas que tiene el teclado que vayamos a usar, en este caso es un teclado matricial de 4×4, ademas se debe asignar un valor para cada tecla del teclado en una matriz NxM.
const byte filas = 4;
const byte columnas = 3;
Creamos una matriz con los números o caracteres que necesitemos
char teclas [filas][columnas]={
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
Configuramos los pines de las filas y columnas que vamos a usar
Debemos designar los pines que vamos a usar para conectar las filas y columnas de nuestro teclado matricial, en este caso es un teclado matricial de 4×4.
byte pinesFilas[filas] = { 11, 10, 9, 8 };
byte pinesColumnas[columnas] = { 7, 6, 5, 4 }; Constructor
Una vez realizada todos los pasos anteriores recién podremos asignar los parámetros necesarios del constructor que son: los valores asignados a cada tecla del teclado matricial, pines usados para la conexión de las filas, pines usados para la conexión de las columnas, el numero de filas y el numero de columnas.
Keypad teclado = Keypad( makeKeymap(teclas), pinesFilas, pinesColumnas, filas, columnas );Funciones de la librería <Keypad.h> para manejar teclados matriciales en Arduino
Saber usar estas funciones es muy importante para sacar el máximo potencial a esta librería, a continuación se hace una descripción de estas funciones.
begin (makeKeymap (userKeymap))
Útil cuando necesitamos asignar varios valores a una misma tecla
char alphaKeys[FILAS][COLUMNAS] = {
{ 'a','d','g' },
{ 'j','m','p' },
{ 's','v','y' },
{ ' ','.','#' }
};
char numberKeys[FILAS][COLUMNAS] = {
{ '1','2','3' },
{ '4','5','6' },
{ '7','8','9' },
{ ' ','0','#' }
};
letras.begin( makeKeymap(alphaKeys) );
numeros.begin( makeKeymap(numberKeys) );
waitForKey ()
Con esta función podemos bloquear todo hasta que se presione una tecla, sin que las interrupciones quedes anuladas en caso que lo estemos usando.
getKey()
Esta función es la más usada, nos devuelve el valor guardado dentro una matriz NxM que representa a la tecla presionada.
getState()
Nos permite saber el estado de las teclas, tienen cuatros estados IDLE (inactivo), PRESSED (presionado), RELEASED (liberado) y HOLD (retenido).
keyStateChanged()
Útil cuando deseamos determinar algún cambio de estado de una tecla.
setHoldTime(tiempo)
Esta función tiene un parámetro tiempo que se debe establecer en milisegundos con un número entero y sin signo, esta función puede determinar el tiempo que debe estar presionado una tecla para que pase al estado HOLD.
setDebounceTime (tiempo)
Con esta función podemos controlar el tiempo de espera para poder realizar una nueva pulsación de otra tecla de nuestro teclado matricial en Arduino, al igual que la anterior función tiene un parámetro de tiempo en milisegundos.
addEventListener (keypadEvent)
Útil para trabajar con eventos, esta función se la debe declarar dentro la función setup()
Ejemplo del manejo de un teclado matricial 4×4 en Arduino con una pantalla LCD 16×2 y un servomotor
Este ejemplo consiste en generar un menú con un teclado matricial y Arduino, este menú se mostrara en la pantalla LCD 16×2 con 4 opciones, el objetivo es manejar los grados de inclinación del eje de un servomotor con la ayuda de un teclado matricial 4×4 [1 = 0º, 2 = 90º, 3 = 180º y * = Manual], el segundo menú sera accionado por la opción manual “*” donde tendrá tres opciones [ A = Cambiar los grados de inclinación del eje del servomotor, B = regresar al menú principal y C = limpiar la pantalla para colocar los grados manualmente].
Si quieres saber mas sobre el manejo de LCD 16×2 entra a este <<ENLACE>>
Si quieres aprender sobre el manejo de servomotores entra a este <<ENLACE>>
Materiales
- Arduino Uno o equivalente
- Teclado matricial 4×4
- Pantalla LCD 16×2
- Potenciometro de 10K
- Resistencia de 220 o 330 ohmios.
- Servomotor SG90 o equivalente
- Cables lo necesario.
Diagrama del circuito para la conexión
Código fuente
/* AUTOR: CREATIVIDAD CODIFICADA
* www.creatividadcodificada.com
* NOMBRE DEL PROYECTO: LCD, KEYPAD Y SERVO CON ARDUINO
*
* ******* [CONTROL DE SERVO MEDIANTE UN MENU ] *******
*/
#include <LiquidCrystal.h> // Librería para el control del LCD
#include <Keypad.h> // Librería para el control del keypad
#include <Servo.h> // Librería para el manejo del servomotor
LiquidCrystal lcd(A0, A1, A2, A3, A4, A5); // variable LCD y pines
const byte filas = 4; // número de filas '4'
const byte columnas = 4; // número de columnas '4'
char teclas [filas][columnas]={
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte filaPines[filas]={11,10,9,8}; //configuración de filas
byte columnaPines[columnas]={7,6,5,4}; // configuración de columnas
Keypad teclado = Keypad (makeKeymap(teclas),filaPines, columnaPines, filas, columnas);
// Caracter personalizado "º"
byte grados[8] = {
0b01110,
0b11011,
0b10001,
0b11011,
0b01110,
0b00000,
0b00000,
0b00000
};
// Servo
Servo servo1;
// variables
char key;
String num, aux;
byte i = 0;
byte menu = 0;
void setup()
{
lcd.begin(16,2);
lcd.createChar(0, grados);
servo1.attach(3,720,2350);
}
void loop()
{
// Menu y submenu
if (menu == 0) menuPrincipal();
if (menu == 1) manual();
}
void menuPrincipal()
{
lcd.setCursor(0,0);
lcd.print("1>0");
lcd.write(byte(0));
lcd.setCursor(8,0);
lcd.print("2>90");
lcd.write(byte(0));
lcd.setCursor(0,1);
lcd.print("3>180");
lcd.write(byte(0));
lcd.setCursor(8,1);
lcd.print("*>MANUAL");
key = teclado.getKey();
// Según la opción que escojamos se activara una acción
if(key == '*') {menu = 1; lcd.clear();}
if(key == '1') servo1.write(0);
if(key == '2') servo1.write(90);
if(key == '3') servo1.write(180);
}
// Submenu "MANUAL"
void manual()
{
lcd.setCursor(0,1);
lcd.print("B<-Back");
lcd.setCursor(8,1);
lcd.print("C<-Clear");
delay(50);
key = teclado.getKey();
if(key != NO_KEY )
{
switch(key)
{
case 'A':
lcd.clear();
lcd.setCursor(3,0);
lcd.print("SERVO ");
lcd.setCursor(9,0);
lcd.print(aux);
lcd.write(byte(0));
if(aux.toInt()>180)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Numero No valido");
}
else servo1.write(aux.toInt());
num = "";
i=0;
break;
case 'B':
lcd.clear();
menu = 0;
break;
case 'C':
lcd.clear();
i=0;
num = "";
break;
case 'D':
// Colocar mas opciones si lo requieres
break;
case '#':
// Colocar mas opciones si lo requieres
break;
case '*':
// Colocar mas opciones si lo requieres
break;
default:
if(i<3)
{
lcd.clear();
lcd.setCursor(6,0);
num = num + key;
lcd.print(num);
aux = num;
i++;
if(i==3)
{
i=0;
num = "";
}
}
break;
}
}
} 
