Teclado matricial 4×4 con Arduino

Usar un teclado matricial 4×4 con Arduino no implica ninguna complejidad, es usada 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.

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 pero podremos manejar 16 pulsadores, si 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 trabaja un teclado matricial 4×4 con Arduino?

Estos teclados matriciales generalmente están conformados por filas y columnas, para un teclado matricial 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.

Configuración del teclado matricial 4×4

Estos teclados matriciales tienen 8 pines donde los 4 primeros son las filas y los 4 restantes son las columnas, esto hace que sea fácil implementarla con Arduino.

Librería para manejar teclados matriciales en Arduino               

Controlar teclados matriciales en Arduino son fáciles de implementar, mas si se tiene conocimiento amplio sobre programación se la puede manejar sin la necesidad de ninguna librería realizando nuestras propias funciones para controlar estos teclados matriciales, en caso que no se tenga estos conocimientos sobre programación ya existe múltiples librerías que nos ayudara a utilizar estos teclados matriciales con 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>

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 la cantidad 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 = 4; 
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] = { 13, 12, 11, 10 }; 
byte pinesColumnas[columnas] = { 9, 8, 7, 6 }; 

Constructor

Una vez realizada todos los pasos anteriores recién podremos asignar los parámetros necesarios del constructor que son:

• Teclas del teclado matricial,
• Filas,
• Columnas,
• la cantidad de filas y la cantidad 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, el tiempo se declara en milisegundos.

addEventListener (keypadEvent)

Útil para trabajar con eventos, esta función se la debe declarar dentro la función setup()

Ejemplo 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> 
#include <Keypad.h> 
#include <Servo.h> 

LiquidCrystal lcd(A0, A1, A2, A3, A4, A5);  
const byte filas = 4; 
const byte 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}; 
byte columnaPines[columnas]={7,6,5,4}; 
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;
      }
    }
  }