¿Alguna vez quisiste agregarle un teclado numérico a un proyecto: una cerradura con clave, un menú para elegir opciones, o un control para ingresar valores? El teclado matricial 4x4 es la pieza que resuelve eso. En esta guía vas a entender cómo funciona por dentro, cómo conectarlo a un Arduino y cómo leer las 16 teclas con la librería Keypad. Al final vas a tener un montaje que enciende un LED y escribe en el monitor serial según la tecla que presiones, y vas a saber exactamente por qué funciona así.

Teclado matricial 4x4 de membrana con su conector de 8 pines

Por qué un teclado 4x4 ocupa solo 8 pines

La gracia de un teclado matricial está en el ahorro de pines. Si conectaras cada uno de los 16 botones de forma independiente, necesitarías 16 entradas en el microcontrolador. En cambio, la matriz organiza esos botones en una grilla de 4 filas y 4 columnas: cada tecla vive en el cruce de una fila con una columna. Así, con 4 líneas para las filas y 4 para las columnas (8 pines en total), podés identificar las 16 teclas sin ambigüedad.

El truco está en cómo se hace la lectura, un proceso que se llama "escaneo de matriz":

  1. Todas las filas y columnas arrancan en alto (1 lógico).
  2. El Arduino pone una sola fila en bajo (0 lógico) y revisa las 4 columnas.
  3. Si alguna columna aparece en bajo, significa que la tecla en ese cruce fila/columna está presionada (cerró el contacto y dejó pasar el 0 de la fila hacia esa columna).
  4. Si ninguna columna está en bajo, el Arduino pasa el 0 a la siguiente fila y repite.

Como este barrido ocurre miles de veces por segundo, para el usuario la respuesta es instantánea. La librería Keypad se encarga de todo este escaneo por vos, pero vale la pena entenderlo: es la misma idea que usan los teclados de computador y los pads de los cajeros.

Materiales

Este proyecto es ideal para partir, porque usa muy pocos componentes:

  • Teclado matricial 4x4 de membrana, con su tira de 8 pines.
  • Arduino Uno (o cualquier placa compatible) como cerebro del montaje.
  • Cables de conexión macho a hembra para unir los pines del teclado a la placa.
  • Un LED (cualquier color) para tener una salida visual, más adelante lo usamos como indicador.

Vista del teclado matricial 4x4 mostrando la disposición de las 16 teclas

Conexión del teclado al Arduino

El teclado expone sus 8 pines en una sola hilera. La convención de este tutorial es directa: los 8 pines del teclado van del pin 9 al pin 2 del Arduino. En concreto, los pines 1 al 4 del teclado (que corresponden a las filas) se conectan a los pines 9, 8, 7 y 6 del Arduino, y los pines 5 al 8 del teclado (las columnas) van a los pines 5, 4, 3 y 2.

Diagrama de conexión del teclado matricial 4x4 a un Arduino Uno

Para entender por qué cada tecla "sabe" dónde está: cuando presionás un botón, se cierra la continuidad entre el pin de su fila y el pin de su columna. Por ejemplo, presionar la tecla 1 crea continuidad entre el pin 1 y el pin 5 del teclado, que en el Arduino son los pines 9 y 5. La librería traduce esa combinación de fila y columna al carácter '1'. El LED, opcional pero útil, lo conectamos al pin 13 para tener una respuesta visible sin depender del computador.

Instalar la librería Keypad

Antes de cargar el código necesitás la librería Keypad en tu carpeta de librerías de Arduino. Podés bajarla desde el enlace que dejamos en la sección de recursos al final y copiarla en la carpeta libraries de tu instalación de Arduino, o instalarla desde el gestor de librerías del IDE buscando "Keypad". Sin esta librería el código no compila, porque la línea #include <Keypad.h> no encuentra el archivo.

El código

El ejemplo hace lo siguiente: al presionar la tecla A escribe "ElectroCrea.com" en el monitor serial y enciende el LED del pin 13; al presionar B apaga el LED y escribe "Visitanos!"; y al presionar los números 1, 2 y 3 los muestra en el monitor serial. Es un esqueleto perfecto para después reemplazar esas acciones por lo que necesite tu proyecto.

Carga este código en tu Arduino tal cual (recuerda configurar la velocidad del monitor serial en 9600 baudios para ver los mensajes):

C++ 
/*ElectroCrea.com

Instrucciones:
--------------------------------------
Conecte los pines 1-8 del KeyPad a los pines 9-2 de Arduino
Conecte un led al pin 13 de Arduino
Recuerda descargar la libreria Keypad
*/

#include <Keypad.h>
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
 {'1','2','3','A'},
 {'4','5','6','B'},
 {'7','8','9','C'},
 {'*','0','#','D'}
};
byte rowPins[ROWS] = {9,8,7,6}; //Filas(pines del 9 al 6)
byte colPins[COLS] = {5,4,3,2}; //Columnas (pines del 5 al)
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
int led = 13;
////////////////////////////////////////////////////////////////////VOID SETUP
void setup(){
Serial.begin (9600);
pinMode(led, OUTPUT);
}
////////////////////////////////////////////////////////////////////VOID LOOP
void loop(){
char key = keypad.getKey();
/////////////////////////////////////////Boton A
if(key) {
switch (key)
{
case 'A'://Cuando key "A" es oprimida...          
Serial.println("ElectroCrea.com");//El monitor serial escribe "ElectroCrea.com"
digitalWrite(led, HIGH);//El led se enciende
break;
}
}
/////////////////////////////////////////Boton B
if(key) {
switch (key)
{
case 'B'://Cuando key "B" es oprimida...          
Serial.println("Visitanos!");//El monitor serial escribe "Visítanos"
digitalWrite(led, LOW);//El led se apaga
break;
}
}
/////////////////////////////////////////Números del 1 al 3
if(key) {
switch (key)
{
case '1':        
Serial.println("1");
break;
}
}
if(key) {
switch (key)
{
case '2':        
Serial.println("2");
break;
}
}
if(key) {
switch (key)
{
case '3':        
Serial.println("3");
break;
}
}
///...
}
//Mas información en ElectroCrea.com

Un detalle del código que conviene comentar: cada tecla se evalúa dentro de su propio bloque if(key) con un switch. Es una forma muy explícita y fácil de leer para principiantes (cada acción queda separada), aunque más adelante, cuando manejes muchas teclas, lo natural es agrupar todo en un único switch (key) con varios case. Para aprender, esta versión paso a paso es ideal porque deja clarísimo qué hace cada tecla.

Cómo probarlo

  1. Conecta el teclado y el LED según el diagrama.
  2. Carga el código al Arduino.
  3. Abre el monitor serial del IDE y configúralo en 9600 baudios.
  4. Presiona teclas: con la A el LED se enciende y aparece "ElectroCrea.com"; con la B se apaga; con 1, 2 o 3 verás el número en pantalla.

Si no ves nada en el monitor serial, revisa primero la velocidad (debe ser 9600), después que la librería Keypad esté bien instalada, y por último que las filas y columnas no estén invertidas: si presionás una tecla y aparece otra, lo más probable es que tengas las filas donde van las columnas. Es el error más común y se arregla intercambiando los dos grupos de cables.

Variantes y mejoras

Una vez que tengas el teclado leyendo bien, estas son tres formas concretas de llevar el proyecto más lejos:

  • Cerradura con clave: guarda una secuencia de teclas (por ejemplo 1, 2, 3, A) en un arreglo y compárala con lo que el usuario ingresa. Si coincide, activa un relé o un servo para abrir una puerta. Es el clásico proyecto de control de acceso casero.
  • Mostrar lo que escribes en una pantalla: en lugar del monitor serial, conecta una pantalla LCD 16x2 (vía I2C para ahorrar pines) y muestra cada tecla en tiempo real. Así el proyecto deja de depender del computador y queda autónomo.
  • Menú de navegación: usa las teclas A, B, C, D como botones de menú (subir, bajar, entrar, volver) para controlar otras funciones de tu proyecto, como elegir modos o ajustar valores.

Personalización para Chile

En Chile consigues los componentes de este proyecto en MechatronicStore:

  • Arduino Uno R3 (SKU X4-8): la placa que usa el tutorial. Es 100% compatible con todo el ecosistema Arduino.
  • Cables macho hembra 40 piezas 20cm (SKU C-412): perfectos para unir los 8 pines del teclado (que son machos) a los conectores hembra del Arduino. Te alcanzan de sobra para este y varios proyectos más.

Si querés exactamente el mismo teclado de membrana 4x4 del tutorial, búscalo en el catálogo como "Teclado matricial 4x4 16 teclas". Y si te quedaste sin stock de esa versión, tené presente que en la tienda también hay variantes equivalentes como el teclado membrana 4x3 (12 teclas) o el matricial 4x5 (20 teclas): la librería Keypad funciona igual, solo cambias el número de filas y columnas y el mapa de teclas en el código.

Recursos

Versión chilena con componentes en stock local en MechatronicStore. Guía basada en el material publicado por ElectroCrea, reescrita y ampliada con explicación del escaneo de matriz, tips de depuración y variantes.