▷ Tutorial de teclado para Arduino, ESP8266 y ESP32 (2024)

En este tutorial se aprende a utilizar el teclado con su microcontrolador Arduino, ESP8266 y también ESP32.

El teclado es uno de los dispositivos de entrada más utilizados para aplicaciones de microcontroladores.

En este tutorial construimos una cerradura que se abre cuando escribimos la contraseña correcta a través del teclado. Como bono se aprende a reducir el número de pines digitales utilizados en su microcontrolador a través de un multiplexor I2C.

En este tutorial se aprende a utilizar el teclado con su microcontrolador Arduino, ESP8266 y también ESP32.

El teclado es uno de los dispositivos de entrada más utilizados para aplicaciones de microcontroladores.

Hay dos versiones diferentes del teclado con la única diferencia en el número de botones:

La versión con 3 columnas y 4 filas que incluye los números del 0 al 9 con el asterisco
y botón de hashtag (#)

Tengo la versión más grande con 4 en lugar de 3 columnas. La versión más grande incluye todos los botones de la versión más pequeña pero también tiene botones para las letras: A, B, C, D

Funcionalidad de matriz de teclado del microcontrolador

El teclado está construido internamente como una matriz con filas y columnas. Si puede identificar una celda en una hoja de Excel con el número de fila y columna, el Arduino puede identificar el botón presionado en el teclado. La siguiente imagen muestra que los primeros 4 conectores identifican el número de fila (R1, R2, R3, R4) y los últimos 3 a 4 conectores identifican el número de columna (C1, C2, C3, C4), según la versión del teclado. .

Pines de teclado

En la tabla de la vista derecha de la imagen, puede ver que si se presiona un botón, el campo del teclado tiene un identificador único, un número de fila y de columna. Por tanto, el microcontrolador es capaz de identificar el campo del teclado mediante un mecanismo de 4 pasos que se describe con la siguiente imagen:

Mecanismo de teclado de 4 pasos
En el estado inactivo, cada pin de fila se establece en BAJO y cada pin de columna se establece en ALTO
Si se presiona un botón, la columna de ese botón se conecta a LOW y, por lo tanto, el pin de la columna se tira de HIGH a LOW. → Se encuentra la columna.
Ahora cada fila se dibuja TOP individualmente, lo que indica R1. Todas las columnas son DÉBILES.

Si la fila en la que se presiona el botón se tira hacia ALTA, la columna cambia de BAJA a ALTA. → Se encuentra la línea.

Cableado entre el microcontrolador y el teclado

Ahora, una vez que sabemos cómo funciona el teclado, te mostramos cómo conectar el teclado a tu microcontrolador. La siguiente imagen muestra el cableado entre el microcontrolador Arduino, ESP8266 y ESP32 más utilizado y el teclado. Si le falta su microcontrolador favorito, deje un comentario al final de este artículo y también agregaré su microcontrolador.

Si desea reducir la cantidad de pines de E / S digitales utilizados, el último capítulo de este tutorial le muestra cómo usar un multiplexor I2C para reducir la cantidad de pines de E / S digitales a dos.

Teclado Arduino Nano

Mini teclado Arduino Pro

Teclado Arduino Uno

Teclado Arduino Mega

Teclado ESP32 NodeMCU

Teclado ESP8266

ESP8266 WeMos D1 Mini teclado

Mostrar el número presionado en el teclado en el Monitor serial

Ahora, una vez que sabemos cómo está conectado el teclado a su microcontrolador, hacemos un ejemplo básico. En este ejemplo, queremos mostrar el número que se presiona en el monitor en serie. Si este ejemplo es demasiado simple para usted, al final de este artículo también hay un ejemplo más avanzado en el que estamos creando un bloqueo de contraseña.

La siguiente tabla le brinda una descripción general de todos los componentes y partes que utilicé para este tutorial.

Arduino Nano	Amazon	AliExpress
Arduino Pro Mini	Amazon	AliExpress
Arduino Uno	Amazon	AliExpress
Arduino Mega	Amazon	AliExpress
ESP32 ESP-WROOM-32	Amazon	AliExpress
ESP8266 NodeMCU	Amazon	AliExpress
ESP8266 WeMos D1 Mini	Amazon	AliExpress
Teclado y pantalla LCD en el kit de sensores	Amazon	AliExpress
Teclado	Amazon	AliExpress
Pantalla LCD 20×4	Amazon	AliExpress
Pantalla LCD 16×2	Amazon	AliExpress

Para este ejemplo utilizamos la librería Keypad de Mark Stanley y Alexander Brevig que hace muy fácil el uso del teclado. Esta librería soporta los teclados 3×4 y 4×4.

#include "Keypad.h"
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',"https://diyi0t.com/keypad-arduino-esp8266-esp32/#",'D'}
};

// For Arduino Microcontroller
byte rowPins[ROWS] = {9, 8, 7, 6}; 
byte colPins[COLS] = {5, 4, 3, 2}; 

// For ESP8266 Microcontroller
//byte rowPins[ROWS] = {D1, D2, D3, D4}; 
//byte colPins[COLS] = {D5, D6, D7, D8}; 

// For ESP32 Microcontroller
//byte rowPins[ROWS] = {23, 22, 3, 21}; 
//byte colPins[COLS] = {19, 18, 5, 17};

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

void setup() {
  Serial.begin(9600);
}

void loop() {
  char key = keypad.getKey();

  if (key){
    Serial.println(key);
  }
}

Habiendo cableado todo, profundicemos en el código del programa:
En la primera línea incluimos el teclado de la biblioteca anterior o ya instalado. A continuación, establecemos el número de filas y columnas para su teclado. En mi caso tengo teclado 4 × 4.

Para poder identificar el teclado de la derecha, creamos una matriz con el teclado. Si su teclado tiene un diseño diferente, puede cambiar el diseño con esta matriz. Asegúrese de que el número de filas y columnas sea correcto.

La última parte del apartado donde definimos las variables para el cableado entre el microcontrolador y el teclado. Puede utilizar todos los pines de E / S digitales en su microcontrolador. En mi caso, utilicé los pines 2 a 9 para Arduino, los pines D1 a D8 para todos los microcontroladores ESP8266 y los primeros pines digitales en un sitio ESP32 NodeMCU. El código del programa está comentado para placas Arduino. Si desea utilizar, por ejemplo, un ESP32 NodeMCU, debe descomentar las líneas de código del ESP32 y comentar las líneas de las placas Arduino.

Entonces, el teclado de la biblioteca necesita saber qué teclado está conectado al microcontrolador. Por lo tanto, creamos un objeto llamado teclado desde la biblioteca y pasamos las variables definidas previamente a este objeto.

Para la función de configuración, establecemos la velocidad en baudios en 9600. Asegúrese de que la velocidad en baudios de su monitor serial en el IDE de Arduino también esté establecida en 9600.

En la función de bucle, primero leemos el carácter que obtenemos en el teclado y almacenamos ese carácter en la variable clave. Si la variable clave no está vacía, imprimimos el carácter en la salida en serie.

La siguiente imagen muestra los números en el monitor de serie.

Salida serial del teclado

Bloqueo de contraseña con teclado y pantalla LCD

Ahora el ejemplo más avanzado donde construimos un candado que se abre cuando ingresamos la contraseña correcta. En este ejemplo, estoy usando el teclado y una pantalla LCD con un Arduino Uno. Si desea usar una placa ESP8266 o ESP32, puede usar el cableado del capítulo anterior y agregar solo la pantalla LCD.

Cableado entre teclado, pantalla LCD y microcontrolador

Tutorial de teclado para Arduino, ESP8266 y ESP32

Verás que solo hemos conectado la pantalla LCD y que la magia está operando dentro del código del programa que explico paso a paso en el siguiente apartado.

#include "Keypad.h"
#include "Wire.h"
#include "LiquidCrystal_I2C.h"

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',"https://diyi0t.com/keypad-arduino-esp8266-esp32/#",'D'}
};

// For Arduino Microcontroller
byte rowPins[ROWS] = {9, 8, 7, 6}; 
byte colPins[COLS] = {5, 4, 3, 2}; 

// For ESP8266 Microcontroller
//byte rowPins[ROWS] = {D1, D2, D3, D4}; 
//byte colPins[COLS] = {D5, D6, D7, D8}; 

// For ESP32 Microcontroller
//byte rowPins[ROWS] = {23, 22, 3, 21}; 
//byte colPins[COLS] = {19, 18, 5, 17};

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
LiquidCrystal_I2C lcd(0x27, 20, 4); 

const int len_key = 5;
char master_key[len_key] = {'1','2','3','4','1'};
char attempt_key[len_key];
int z=0;

void setup() {
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Insert Password");
}

void loop() {
  char key = keypad.getKey();
  lcd.setCursor(z-1,1);
  lcd.print("*");
  if (key){
    switch(key){
      case '*':
        z=0;
        break;
      case "https://diyi0t.com/keypad-arduino-esp8266-esp32/#":
        delay(100); // added debounce
        checkKEY();
        break;
      default:
         attempt_key[z]=key;
         z++;
      }
  }
}

void checkKEY()
{
   int correct=0;
   int i;
   for (i=0; i<len_key; i++) {
    if (attempt_key[i]==master_key[i]) {
      correct++;
      }
    }
   if (correct==len_key && z==len_key){
    lcd.setCursor(0,1);
    lcd.print("Correct Key");
    delay(3000);
    z=0;
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Insert Password");
   }
   else
   {
    lcd.setCursor(0,1);
    lcd.print("Incorrect Key");
    delay(3000);
    z=0;
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Insert Password");
   }
   for (int zz=0; zz<len_key; zz++) {
    attempt_key[zz]=0;
   }
}

Código de programa Arduino para un bloqueo de contraseña de teclado

La primera parte del código es prácticamente la misma, solo que incluimos la biblioteca de pantalla LCD LiquidCrystal_I2C.h y creamos un objeto a partir de esa biblioteca llamado lcd. Estoy usando una pantalla LCD de 20 × 4 en la dirección I2C 0x27 para este ejemplo. Si usa uno diferente, necesita modificar los parámetros del objeto lcd.

También puedes visitar mi tutorial de pantallas LCD, donde aprenderás todo lo que necesitas saber sobre las diferentes pantallas LCD y cómo usarlas.

Para este ejemplo, estamos definiendo nuevas variables:
len_key es una constante que define la longitud de la contraseña.
master_key es la matriz en la que almacenamos la contraseña correcta.
try_key es la matriz en la que almacenamos los caracteres ingresados por el usuario a través del teclado.[z=2] z es la variable que apunta al lugar correcto en las matrices master_key y try_key, comenzando con 0. Por ejemplo: char master_key = 3.

En la función de configuración agregamos nuevos líneas para que la pantalla LCD encienda la luz de fondo de la pantalla e imprima “Insertar contraseña” en la primera línea.

La función de bucle comienza con la lectura del carácter del teclado. Esto se hace mediante la función getKey del objeto clave creado anteriormente.

Como quiero ver como usuario de bloqueo de contraseña cuántos caracteres ya escribí, imprimimos un asterisco por cada carácter ingresado por el usuario. Por lo tanto, colocamos el cursor de la pantalla LCD en z-1 y no en z en la segunda línea de la pantalla e imprimimos el carácter de asterisco.

Una vez que el usuario ingresa una clave, llegamos a alguna lógica de cambio de caso en el script del programa ya que queremos realizar diferentes tareas, dependiendo de la clave ingresada por el usuario:
Si la entrada es «*» → queremos resetear la entrada y empezar de nuevo desde el principio para darle al usuario la posibilidad de borrar las inserciones anteriores. Quizás el usuario ingresó un carácter incorrectamente.
Si la entrada es «#» → queremos comprobar si la clave total es válida con una función checkKey, que explicaré en el siguiente apartado. De lo contrario, lo agregamos a la matriz try_key y aumentamos el «puntero» de la matriz try_key para escribir la siguiente entrada en el siguiente lugar de la matriz.

En esta función checkKEY, verificamos si la clave actual en la matriz try_key es la misma que la que guardamos en la matriz master_key.

Primero, creamos una nueva variable correcta para contar el número de caracteres idénticos entre la matriz try_key y master_key. Por lo tanto, verificamos elemento por elemento de la matriz y si coincide, aumentamos la variable correcta. También verificamos si la longitud de la clave de entrada tiene la misma longitud que la clave len_key. De lo contrario, una clave como: [1,2,3,4,1,8] sería correcto porque los primeros elementos comparados carácter por carácter son válidos.

Una vez que se han comparado todos los elementos y la variable correcta tiene la misma longitud que la clave maestra, queda claro que la clave ingresada era correcta.
Imprimimos en la pantalla que la clave era correcta y esperamos 3 segundos antes de borrar la pantalla y reiniciar la solicitud de contraseña.

Si la clave era incorrecta, la imprimimos en la pantalla y también esperamos 3 segundos antes de borrar la pantalla y reiniciar la solicitud de contraseña.

De cualquier manera, eliminamos las entradas clave anteriores y establecemos el puntero de la matriz try_key en el primer elemento 0.

El siguiente video muestra la funcionalidad del registro del teclado.

Primero ingresé la contraseña incorrecta.
Luego escribo la contraseña correcta.
Al final, ingresé la contraseña incorrecta, pero los primeros caracteres son los correctos. La contraseña es demasiado larga.

https://youtu.be/k9iMuX_uSuQ

Arduino Keypad Tutorial (https://youtu.be/k9iMuX_uSuQ)

Reduzca la cantidad de pines digitales con un multiplexor I2C

Dado que el teclado usado en este tutorial usa 8 pines de E / S digitales en el microcontrolador, es útil reducir la cantidad de pines usados con un multiplexor PCF8574 I2C.

El PCF8574 es un módulo de expansión de entrada / salida (E / S) de 8 bits para I2C, que usa solo dos pines para la comunicación. Si desea obtener más información sobre el multiplexor y la comunicación I2C, puede visitar mi artículo tutorial de I2C.

La imagen del lado derecho muestra los pines del PCF8574 y la siguiente imagen muestra el cableado entre el microcontrolador Arduino, ESP8266 o ESP32, el multiplexor I2C y el teclado.

Cableado entre teclado, multiplexor I2C y microcontrolador

Arduino Nano

Arduino Pro Mini

Arduino Uno

Arduino Mega

ESP32 NodeMCU

ESP8266 NodeMCU

ESP8266 WeMos D1 Mini

Programa para leer números de teclado con multiplexor I2C

Para el script del programa, necesitamos instalar la biblioteca I2CKeyPad de Rob Tillaart que se encuentra en el administrador de bibliotecas del IDE de Arduino.

En la siguiente sección, revisamos el código del programa para usar la extensión I2C en combinación con el teclado. Debido a que no usamos pines específicos del microcontrolador, el código del programa es válido para Arduino, ESP8266 y ESP32.

#include "Wire.h"
#include "I2CKeyPad.h"

const uint8_t KEYPAD_ADDRESS = 0x20;
uint8_t lastKey;

I2CKeyPad keyPad;

void setup()
{
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);
  if (keyPad.begin(KEYPAD_ADDRESS) == false)
  {
    Serial.println("nERROR: cannot communicate to keypad.nPlease reboot.n");
    while(1);
  }
}

void loop()
{
  char keys[] = "123A456B789C*0#DNF";  // N = Nokey, F = Fail
  
  uint8_t idx = keyPad.getKey();
  if (idx != lastKey & keys[idx] != 'N') {
    Serial.println(keys[idx]);
    lastKey = idx;
    }
  delay(100);
}

En la primera parte del script del programa, incluimos la biblioteca Wire, para comunicarse a través de I2C y la biblioteca I2CKeyPad que nos ayuda a mapear las señales del teclado al protocolo de comunicación I2C.

Después de incluir las bibliotecas, debemos configurar la dirección I2C HEX del PCF8574. En la mayoría de los casos, la dirección debe ser 0x20, pero puede usar el escáner de direcciones I2C HEX del tutorial I2C para encontrar rápidamente la dirección.

Ahora, creamos un objeto I2CKeyPad llamado keyPad y también configuramos una variable para almacenar la última posición presionada en el teclado, llamada lastKey. El tipo de datos uint8_t es un entero sin signo de 8 bits.

En la función de configuración, la velocidad en baudios se establece en 115200, que debe coincidir con la velocidad en baudios del monitor en serie si luego queremos ver la tecla presionada. Una vez que se inicializa la comunicación I2C, la velocidad del reloj I2C se establece en 400000 y definimos una captura de error si la dirección HEX no es la correcta.

En la función de bucle, primero creamos una matriz de teclas del teclado. En mi caso, tengo un teclado 4 × 4. Las dos últimas entradas nos ayudan a obtener los valores de la biblioteca si no se presiona ninguna tecla o falla la lectura del teclado. Con la función getKey, almacenamos la posición actual presionada en el teclado en la variable idx.

En la condición if definimos que solo se presiona la tecla actual, cuando la tecla es diferente a la anterior, y solo si se presiona una tecla. Por lo tanto, buscamos la tecla presionada en la matriz de teclas con la posición del teclado que está almacenada en la variable idx. En el último paso, guardamos la posición actual del teclado en la variable lastKey y establecemos un pequeño retraso de 0,1 segundos.

La salida del multiplexor I2C es la misma que no usa el multiplexor. Pero puede registrar una gran cantidad de pines de E / S digitales en su microcontrolador. La siguiente imagen muestra el ejemplo con el multiplexor I2C.

Conclusión

Espero que te haya gustado este tutorial donde aprendiste a usar el teclado como dispositivo de entrada y cómo crear un candado que se abre cuando ingresamos la contraseña correcta. Si desea reducir la cantidad de pines de E / S digitales utilizados, le recomiendo que lea el artículo sobre multiplexor digital.

¿Cuál es tu próximo proyecto? ¿Usarás el teclado? Házmelo saber en la sección de comentarios.
Si tiene alguna pregunta con respecto a este tutorial, use la sección de comentarios a continuación para hacer sus preguntas. Les respondo lo antes posible.