¿Quieres que tu proyecto tenga una clave de acceso, un menú de opciones o simplemente un montón de botones sin soldar treinta cables? Un teclado matricial resuelve eso en un solo componente. En este tutorial vas a aprender a conectar teclados numéricos a un Arduino, leer las teclas con la librería Keypad y mostrar lo que escribes en una pantalla LCD I2C. Cerramos con un proyecto completo: un sistema de clave PIN de seis dígitos que decide qué hacer según el número que ingresas.

Al terminar vas a entender cómo funciona internamente la matriz de filas y columnas, cómo adaptar el código a teclados de 12 o 16 teclas, y cómo armar la base de una cerradura electrónica casera.

Teclado numérico de 12 teclas y teclado matricial de 16 teclas listos para conectar a Arduino

Cómo funciona un teclado matricial

Antes de cablear, conviene entender el truco. Un teclado de 16 botones no usa 16 cables: usa apenas 8. Los botones están organizados en una matriz de 4 filas por 4 columnas. Cada tecla es un pulsador que conecta una fila con una columna específica. Cuando presionas el "5", se cierra el contacto entre su fila y su columna, y la librería Keypad detecta esa combinación única para saber qué botón apretaste.

Esto es lo que hace tan eficientes a estos teclados: con N filas y M columnas controlas N por M botones usando solo N más M pines. Un teclado 4x4 te da 16 teclas con 8 pines; uno 4x3 te da 12 teclas con 7 pines.

Diagrama de pinout de un teclado matricial con sus filas y columnas

Antes de empezar: identifica filas y columnas

Sin importar de dónde venga tu teclado, lo primero es ubicar qué pin corresponde a cada fila y a cada columna. Si tienes la hoja de datos (datasheet), ahí viene todo y te ahorras el trabajo. Si no la tienes, no hay problema: lo resuelves con un multímetro en modo continuidad (el del pitido).

Pon una punta en el pin 1 y la otra en el pin 2, y anda apretando teclas una por una. Cuando una tecla cierre el circuito y suene el pitido, anota qué pin con qué pin la activa. Repite moviendo las puntas pin por pin. En pocos minutos vas a tener el mapa completo de filas y columnas. Por ejemplo, en un teclado típico los pines 1 y 5 corresponden al botón "1", y los pines 2 y 5 al botón "4".

Una vez que sepas el cableado, instala la librería Keypad desde el gestor de librerías del IDE de Arduino (Programa > Incluir Librería > Administrar Bibliotecas, busca "Keypad" de Mark Stanley y Alexander Brevig).

Ejemplo 1: teclado de 12 teclas con LCD I2C

Para este primer ejemplo usamos el teclado pequeño de 12 botones (3 columnas por 4 filas), un Arduino Uno compatible y una pantalla LCD con interfaz I2C. Si no tienes LCD, puedes mandar el texto al monitor serial en vez de a la pantalla.

Conecta la LCD por I2C (SDA y SCL del Arduino) y luego cablea el teclado así:

Fila 1 del teclado al pin digital 5 del Arduino
Fila 2 al pin digital 4
Fila 3 al pin digital 3
Fila 4 al pin digital 2
Columna 1 al pin digital 8
Columna 2 al pin digital 7
Columna 3 al pin digital 6

Si tu teclado es distinto al nuestro, fíjate en las líneas del sketch a partir del comentario // keypad type definition. Ahí tienes que cambiar los números de los arreglos rowPins[ROWS] y colPins[COLS] por los pines digitales que conectaste a tus filas y columnas. El arreglo keys guarda qué carácter se muestra al presionar cada botón: lo dejamos igual al teclado físico, pero puedes cambiarlo a lo que necesites.

Cuando estés conforme con la asignación de pines, carga este sketch:

C++

/* Numeric keypad and I2C LCD
   http://tronixstuff.com
   Uses Keypad library for Arduino
   http://www.arduino.cc/playground/Code/Keypad
   by Mark Stanley, Alexander Brevig */

#include "Keypad.h"
#include "Wire.h" // for I2C LCD
#include "LiquidCrystal_I2C.h" // for I2C bus LCD module 
// http://www.dfrobot.com/wiki/index.php/I2C/TWI_LCD1602_Module_(SKU:_DFR0063)
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

// keypad type definition
const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] =
 {{'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}};

byte rowPins[ROWS] = {
  5, 4, 3, 2}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {
  8, 7, 6}; // connect to the column pinouts of the keypad

int count=0;

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup()
{
  lcd.init();          // initialize the lcd
  lcd.backlight(); // turn on LCD backlight
}

void loop()
{
  char key = keypad.getKey();
  if (key != NO_KEY)
  {
    lcd.print(key);
    count++;
    if (count==17)
    {
      lcd.clear();
      count=0;
    }
  }
}

Con esto, cada vez que apretes una tecla aparece su carácter en la LCD, y al llegar a 17 caracteres la pantalla se limpia sola para no desbordarse.

Ejemplo 2: teclado de 16 teclas (4x4)

Ahora pasamos al teclado más grande de 16 botones (4 columnas por 4 filas), que agrega la columna extra con las letras A, B, C y D. Otra vez usamos un Arduino Uno compatible y una LCD I2C (acá el tutorial original usa una LCD I2C de Akafugu).

Cablea la LCD y conecta el teclado de esta forma:

Fila 1 (pin 8) al pin digital 5 del Arduino
Fila 2 (pin 1) al pin digital 4
Fila 3 (pin 2) al pin digital 3
Fila 4 (pin 4) al pin digital 2
Columna 1 (pin 3) al pin digital 9
Columna 2 (pin 5) al pin digital 8
Columna 3 (pin 6) al pin digital 7
Columna 4 (pin 7) al pin digital 6

Para el código fíjate en tres cambios respecto al ejemplo anterior: hay una columna extra en el arreglo char keys[], un pin extra en colPins[], y COLS ahora vale 4.

C++

/* Numeric keypad and I2C LCD
   http://tronixstuff.com
   Uses Keypad library for Arduino
   http://www.arduino.cc/playground/Code/Keypad
   by Mark Stanley, Alexander Brevig */

#include "Keypad.h"
#include "Wire.h" // for I2C LCD
#include "TWILiquidCrystal.h"
// http://store.akafugu.jp/products/26
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
char keys[ROWS][COLS] =
 {{'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}};
byte rowPins[ROWS] = {
  5, 4, 3, 2}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {
  9, 8, 7, 6}; //connect to the column pinouts of the keypad
int count=0;

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.print("Keypad test!");  
  delay(1000);
  lcd.clear();
}

void loop()
{
  char key = keypad.getKey();
  if (key != NO_KEY)
  {
    lcd.print(key);
    Serial.print(key);
    count++;
    if (count==17)
    {
      lcd.clear();
      count=0;
    }
  }
}

Teclado matricial de 16 teclas tipo membrana 4x4 visto de frente

Proyecto: sistema de clave PIN

Llegamos a lo más pedido: usar el teclado como teclado de seguridad. La idea es que el Arduino ejecute una acción cuando ingresas la clave correcta. El siguiente sketch implementa una clave PIN de seis dígitos usando el mismo hardware del ejemplo anterior (teclado 4x4 más LCD I2C).

La lógica es simple: vas escribiendo dígitos, presionas # para confirmar y la función checkPIN() compara tu intento con la clave guardada en el arreglo char PIN[6]. Si los seis caracteres coinciden, se ejecuta correctPIN(); si no, se ejecuta incorrectPIN(). La tecla * reinicia el ingreso por si te equivocaste. Las acciones que quieras disparar (abrir una cerradura, encender un relé, mostrar un mensaje) las pones dentro de correctPIN() e incorrectPIN().

La clave de fábrica en este ejemplo es 1, 2, A, D, 5, 6. Con un poco más de trabajo puedes incluso programar una función para que el usuario cambie su propia clave.

C++

// PIN switch with 16-digit numeric keypad
// http://tronixstuff.com
#include "Keypad.h"
#include <Wire.h>
#include <TWILiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
char keys[ROWS][COLS] =
{
  {
    '1','2','3','A'  }
  ,
  {
    '4','5','6','B'  }
  ,
  {
    '7','8','9','C'  }
  ,
  {
    '*','0','#','D'  }
};
byte rowPins[ROWS] = {
  5, 4, 3, 2}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {
  9, 8, 7, 6}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

char PIN[6]={
  '1','2','A','D','5','6'}; // our secret (!) number
char attempt[6]={ 
  '0','0','0','0','0','0'}; // used for comparison
int z=0;

void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.print("PIN Lock ");
  delay(1000);
  lcd.clear();
  lcd.print("  Enter PIN...");
}

void correctPIN() // do this if correct PIN entered
{
  lcd.print("* Correct PIN *");
  delay(1000);
  lcd.clear();
  lcd.print("  Enter PIN...");
}

void incorrectPIN() // do this if incorrect PIN entered
{
  lcd.print(" * Try again *");
  delay(1000);
  lcd.clear();
  lcd.print("  Enter PIN...");
}

void checkPIN()
{
  int correct=0;
  int i;
  for ( i = 0;   i < 6 ;  i++ )
  {

    if (attempt[i]==PIN[i])
    {
      correct++;
    }
  }
  if (correct==6)
  {
    correctPIN();
  } 
  else
  {
    incorrectPIN();
  }

  for (int zz=0; zz<6; zz++) 
  {
    attempt[zz]='0';
  }
}

void readKeypad()
{
  char key = keypad.getKey();
  if (key != NO_KEY)
  {
    attempt[z]=key;
    z++;
    switch(key)
    {
    case '*':
      z=0;
      break;
    case '#':
      z=0;
      delay(100); // for extra debounce
      lcd.clear();
      checkPIN();
      break;
    }
  }
}

void loop()
{
  readKeypad();
}

Variantes y mejoras

Este proyecto es una base ideal para ir más lejos. Algunas ideas concretas que el tutorial original no cubre:

Cerradura real con relé: dentro de correctPIN(), activa un módulo relé conectado a un pin digital para liberar una cerradura electromagnética o un pestillo solenoide. Así pasas de un demo en pantalla a una cerradura funcional.
Aviso sonoro con buzzer: agrega un buzzer activo a un pin digital y hazlo sonar corto cuando la clave es correcta y largo cuando es incorrecta. Mejora muchísimo la experiencia de uso sin mirar la pantalla.
Bloqueo tras varios intentos fallidos: lleva un contador de errores y, si llega a tres, congela el teclado por treinta segundos con un delay(). Es una defensa básica contra adivinar la clave por fuerza bruta.
Sin pantalla, solo serial: si quieres ahorrar la LCD para prototipar rápido, reemplaza las líneas lcd.print() por Serial.print() y observa todo en el monitor serial del IDE.

Personalización para Chile

En Chile puedes conseguir todo lo necesario en MechatronicStore, con stock local y despacho rápido:

Arduino Uno R3 (SKU X4-8): la placa base del tutorial. El original menciona un "Arduino Uno compatible", y esta cumple exactamente esa función.
Teclado Membrana 4×3 (SKU G-335): equivale al teclado de 12 botones del primer ejemplo (3 columnas por 4 filas).
Teclera keypad tipo membrana 4×4 (SKU G-303): el teclado de 16 teclas con las letras A, B, C y D del segundo ejemplo y del proyecto de clave PIN.
Pantalla LCD1602 16×2 con I2C incorporado (SKU N-301 equivalente): la pantalla que muestra los caracteres. Trae el módulo I2C integrado, así que la conectas con solo cuatro cables (VCC, GND, SDA, SCL).

Si en algún tutorial en inglés ves una LCD de marca como Akafugu, la LCD1602 con I2C del catálogo hace lo mismo a un precio mucho más accesible.

Recursos

Tutorial original: Numeric Keypads and Arduino por John Boxall en tronixstuff.com
Librería Keypad para Arduino: Keypad (Mark Stanley, Alexander Brevig)
Librería LiquidCrystal I2C: documentación del módulo LCD1602 con interfaz I2C

Versión chilena basada en el tutorial de John Boxall, con componentes en stock local en MechatronicStore.

Teclados matriciales con Arduino: lee teclas y arma una clave PIN

Lista de materiales

Cómo funciona un teclado matricial

Antes de empezar: identifica filas y columnas

Ejemplo 1: teclado de 12 teclas con LCD I2C

Ejemplo 2: teclado de 16 teclas (4x4)

Proyecto: sistema de clave PIN

Variantes y mejoras

Personalización para Chile

Recursos

Tutoriales relacionados

Sensor de temperatura NTC 10K con Arduino: del divisor a los grados Celsius

Teclado matricial 4x4 con Arduino: lee 16 teclas con solo 8 pines

Arduino en la red: arma un servidor web con un Ethernet shield W5100

Enciende un LED desde tu celular con el módulo Bluetooth HC-06 y Arduino

Comentarios