Chisme 129 · El lector de códigos del Lince: teclado matricial 4x4

Practica aquí antes de tocar la placa. El teclado de membrana no lleva electrónica: es solo una rejilla de 16 interruptores. Vas a conectar sus 8 hilos a la ESP32 Plus, descubrir cuáles son filas y cuáles columnas, completar el programa que lo lee y probar las 16 teclas. Cada paso se desbloquea al completar el anterior.

Modo práctica (paso a paso)Modo demostración (verlo todo hecho)

Prototipo educativo. Este simulador usa los pines y el orden de hilos de un teclado concreto; el tuyo puede ser distinto, y por eso el paso 3 sirve para descubrirlo.

El teclado y el monitor serie

Teclado 4×4

Pulsa las teclas con el ratón o con el dedo. No funcionan hasta conectar los cables (paso 1).

Monitor serie (115200)
cables sin conectar

1Conecta los cables

La cinta del teclado termina en 8 hilos. Cuéntalos de izquierda a derecha: hilo 1, hilo 2… hilo 8. No hace falta alimentación ni GND: el teclado solo son interruptores. Elige a qué pin de la ESP32 Plus va cada hilo. Usamos pines con conector macho, sin los de arranque (como el 12).

Hilo 1 → pin
Hilo 2 → pin
Hilo 3 → pin
Hilo 4 → pin
Hilo 5 → pin
Hilo 6 → pin
Hilo 7 → pin
Hilo 8 → pin

2Qué es una matriz de teclas

Las 16 teclas están colocadas en 4 filas y 4 columnas. Cada tecla es un interruptor entre una fila y una columna.

3Descubre filas y columnas

Ahora la placa ejecuta el programa de descubrimiento: pone cada hilo en bajo, uno a uno, y mira qué otro hilo cae con él. Pulsa al menos 6 teclas distintas del teclado de arriba y mira qué parejas de hilos salen en el monitor.

Teclas distintas probadas: 0 / 6

4Completa el programa

Este es el programa final. Completa las líneas importantes:

5Pruébalo y piensa como un científico

Ya funciona el programa final: cada pulsación sale una sola vez, con su letra o número. Pulsa las 16 teclas.

Teclas probadas: 0 / 16

Lee y predice

Pulsas la tecla D. ¿Qué dos hilos se unen?La D está en la fila 4 (hilo 4) y en la columna 4 (hilo 8): se unen los hilos 4 y 8.
Pulsas dos teclas a la vez, en la misma fila. ¿Qué pasa?Se unen la misma fila con dos columnas. El programa detecta la primera columna que encuentra y devuelve una sola tecla. Con tres teclas a la vez, algunas matrices sin diodos pueden dar «teclas fantasma».
Programa para descubrir las filas y columnas (Arduino IDE)
// Chisme 129 - Descubrir filas y columnas del teclado de membrana 4x4
// Placa en Arduino IDE: ESP32 Dev Module. Monitor serie a 115200.
// Hilo 1 = pin 13, hilo 2 = 14, hilo 3 = 27, hilo 4 = 16, hilo 5 = 17, hilo 6 = 25, hilo 7 = 19, hilo 8 = 18.

const int P[8] = {13, 14, 27, 16, 17, 25, 19, 18};

void setup() {
  Serial.begin(115200);
  for (int i = 0; i < 8; i++) pinMode(P[i], INPUT_PULLUP);   // todos como entrada con pull-up
  Serial.println("Pulsa teclas...");
}

void loop() {
  for (int i = 0; i < 8; i++) {
    pinMode(P[i], OUTPUT);
    digitalWrite(P[i], LOW);              // ponemos este hilo a 0
    delayMicroseconds(50);
    for (int j = 0; j < 8; j++) {
      if (j != i && digitalRead(P[j]) == LOW) {   // otro hilo ha caido a 0: estan unidos
        Serial.print("Unidos hilo "); Serial.print(i + 1);
        Serial.print(" y hilo ");     Serial.println(j + 1);
      }
    }
    pinMode(P[i], INPUT_PULLUP);          // lo devolvemos a entrada
  }
  delay(150);
}
Programa final del teclado (Arduino IDE)
// Chisme 129 - Teclado de membrana 4x4 con la ESP32 Plus de Acebott
// Placa en Arduino IDE: ESP32 Dev Module. Monitor serie a 115200.
// Sin librerias: leemos la matriz "a mano".
//
// Hilos de la cinta (de izquierda a derecha) -> pines de la ESP32:
//   Filas    (hilos 1 a 4): 13, 14, 27, 16
//   Columnas (hilos 5 a 8): 17, 25, 19, 18

const int FILAS[4]    = {13, 14, 27, 16};
const int COLUMNAS[4] = {17, 25, 19, 18};

const char TECLAS[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

char ultima = 0;   // ultima tecla detectada (para no repetirla mientras sigue pulsada)

// Devuelve la tecla pulsada, o 0 si no hay ninguna
char leerTecla() {
  for (int f = 0; f < 4; f++) {
    pinMode(FILAS[f], OUTPUT);
    digitalWrite(FILAS[f], LOW);          // activamos esta fila (la ponemos a 0)
    delayMicroseconds(50);
    for (int c = 0; c < 4; c++) {
      if (digitalRead(COLUMNAS[c]) == LOW) {   // la columna cae a 0: esta tecla esta pulsada
        pinMode(FILAS[f], INPUT);
        return TECLAS[f][c];
      }
    }
    pinMode(FILAS[f], INPUT);             // desactivamos la fila (alta impedancia)
  }
  return 0;
}

void setup() {
  Serial.begin(115200);
  for (int f = 0; f < 4; f++) pinMode(FILAS[f], INPUT);
  for (int c = 0; c < 4; c++) pinMode(COLUMNAS[c], INPUT_PULLUP);   // columnas con pull-up
  Serial.println("Teclado listo. Pulsa teclas...");
}

void loop() {
  char t = leerTecla();
  if (t != 0 && t != ultima) {            // tecla nueva
    Serial.print("Tecla: ");
    Serial.println(t);
  }
  ultima = t;                             // si soltamos, ultima = 0 y se puede repetir
  delay(20);                              // pequeno antirrebote
}

Placa ESP32 Plus de Acebott, programada con Arduino IDE (ESP32 Dev Module). Teclado de membrana 4×4 de 8 hilos.