Cómo utilizar un teclado con Arduino

Cómo utilizar un teclado con Arduino

Este artículo le dará toda la información necesaria sobre cómo interconectar el teclado con la placa Arduino UNO.

Te mostraré cómo interconectar los teclados 4×3 y 4×4 con la placa Arduino UNO.

Al final, también te proporcionaré el código para almacenar las contraseñas en la EEPROM y cambiar la contraseña existente.

Suministros

Componentes de hardware

Arduino Uno Rev3x1Amazon
Teclado de matriz plana 4×4x1Amazon
Teclado de matriz plana 4×3x1Amazon
Cable USB tipo A/Bx1Amazon

Software

Arduino IDEArduino IDE

Makerguides.com participa en el Programa de Asociados de Amazon Services LLC, un programa de publicidad de afiliados diseñado para proporcionar un medio para que los sitios ganen honorarios de publicidad mediante la publicidad y los enlaces a productos en Amazon.com.

¿Qué es un teclado?

Un teclado es un dispositivo que puede utilizarse para recibir datos de entrada de un usuario y una disposición sistemática de botones en posición horizontal y vertical. 

¿Por qué necesita un teclado?

Cuando queremos interconectar una tecla con el microcontrolador, entonces necesita un pin GPIO. Pero cuando queremos interconectar muchas teclas como 9, 12, o 16, etc., entonces puede adquirir todos los pines GPIO del microcontrolador.

Para ahorrar algunos pines GPIO del microcontrolador, podemos utilizar el Keypad matricial. Un Keypad matricial no es más que teclas dispuestas en filas y columnas.

Por ejemplo, si queremos interconectar 16 teclas con el microcontrolador, necesitaremos 16 pines GPIO, pero si utilizamos un teclado matricial 4×4, sólo necesitaremos 8 pines GPIO del microcontrolador.

¿Por qué necesita un teclado?

Hay varios tipos de teclados disponibles en el mercado, pero los tamaños más comunes son 4×3, 4×4 y 4×5.

Estos números indican el número de filas y columnas de los teclados.

Por ejemplo, un teclado 4×4 consta de 16 teclas o botones que están dispuestos en 4 filas y 4 columnas.

¿Cuál es el orden de los pines en un teclado de 4 por 4?

El teclado 4×4 tiene 4 filas y 4 columnas. Los primeros cuatro pines se utilizan como filas y los últimos cuatro pines se utilizan como columnas.

Las filas se mencionan como R1, R2, R3, R4, y las columnas como C1, C2, C3 y C4.

¿Cuál es el orden de los pines en un teclado de 4 por 4?

Del mismo modo, en los teclados de 4 por 3, los primeros 4 pines son para las filas, es decir, R1, R2, R3, R4, y los 3 pines restantes son para la columna, es decir, C1, C2 C3.

Teclados de 4 por 3

¿Cómo funciona un teclado 4×4 en un Arduino?

Hay múltiples formas de escanear una matriz de Keypad. El funcionamiento de un teclado 4×4 puede entenderse mediante los siguientes pasos.

Paso 1: Inicialmente, si no se pulsa ninguna tecla, los pines de las filas, es decir, R1, R2, R3 y R4 están en 0 lógico, y los pines de las columnas C1, C2, C3 y C4 están en 1 lógico.

Cómo funciona un teclado 4x4 en un Arduino

Paso 2: Si se pulsa la tecla numérica 9, entonces la fila R3 entrará en contacto con la columna C3, y por lo tanto C3 se pondrá a tierra, y estará en lógica 0. 

Ahora, cuando el MCU de Arduino escanea y lee la columna, puede identificar que la tecla de la columna C3 está presionada porque el valor de C3 cambiará de 1 lógico a 0.

cuando el Arduino MCU escanea y lee la columna

Paso 3: Para identificar qué tecla se ha pulsado, Arduino pondrá la línea de fila en alto una a una. Cuando llega a R3, C3 vuelve a ponerse en High, y así Arduino puede detectar que la tecla 9 ha sido pulsada por el usuario.

identificar qué tecla se ha pulsado, Arduino

¿Cómo puedo conectar el teclado 4×3 o 4×4 al Arduino UNO?

La interconexión de un teclado 4×3 o 4×4 es muy sencilla. Sólo hay que conectar las filas y columnas del teclado a los pines de Arduino Uno.

Pin de Arduino UNOTeclado 4×3Teclado 4×4
12R1R1
11R2R2
10R3R3
9R4R4
8C1C1
7C2C2
6C3C3
5-C4

A continuación se muestra la interconexión del teclado 4×4 y 4×3 con la placa Arduino Uno.

Teclado 4×4
Teclado 4×3

Biblioteca de teclado para Arduino

Ahora, te contaré cómo instalar la librería Keypad en tu IDE de Arduino.

Paso 1: Para instalar la biblioteca vaya a Sketch > Incluir biblioteca> Gestionar bibliotecas.

Para instalar la Biblioteca

Paso 2: En la ventana de Gestión de Bibliotecas, escriba el teclado en el cuadro de búsqueda, se mostrarán los resultados. Debe instalar Keypad de Mark Stanley y Alexander Brevig.

Ahora selecciona la última versión de la placa y haz clic en instalar.

Ventana de gestión de bibliotecas

Ahora, tu IDE de Arduino está listo para usar la librería Keypad.

-> Lea nuestra guía sobre lo que puede construir con Adruino.

Código Arduino para el teclado 4×4

#include <Keypad.h>

const byte row_count = 4;
const byte column_count = 4;

byte row_pins[row_count] = {12, 11, 10, 9};
byte column_pins[column_count] = {8, 7, 6, 5};

char password = 'D';
char key_value;

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

Keypad myKeypad = Keypad(makeKeymap(keys4x4), row_pins, column_pins, row_count, column_count);

void setup() {
  Serial.begin(9600);
  Serial.println("Keypad Test..");
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
}

void loop() {
  
  key_value = myKeypad.getKey();
  
  if (key_value)
  {
    Serial.print(key_value);
    Serial.println(" Key is pressed");

    if (key_value == password) 
    {
      Serial.println("LED ON");
      digitalWrite(13, HIGH);
      delay(2000);
      digitalWrite(13, LOW);
    }
  }
}

Salida de monitor en serie:

Salida de monitorización en serie

Código Arduino para teclado 4×3

#include <Keypad.h>
const byte row_count = 4;
const byte column_count = 3;

byte row_pins[row_count] = {12, 11, 10, 9};
byte column_pins[column_count] = {8, 7, 6 };

char password = '#';
char key_value;

char keys4x3[row_count][column_count] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

Keypad myKeypad = Keypad(makeKeymap(keys4x3), row_pins, column_pins, row_count, column_count);

void setup() {
  Serial.begin(9600);
  Serial.println("Keypad Test..");
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
}

void loop() {
  
  key_value = myKeypad.getKey();
  
  if (key_value)
  {
    Serial.print(key_value);
    Serial.println(" Key is pressed");

    if (key_value == password) 
    {
      Serial.println("LED ON");
      digitalWrite(13, HIGH);
      delay(2000);
      digitalWrite(13, LOW);
    }
  }
}

Salida de monitor en serie:

Salida de monitorización en serie

Cómo funciona el código

En primer lugar, incluya la librería Keypad y defina el número de filas y columnas del Keypad. Para el teclado 4×4, defina 4 filas y 4 columnas, y para el teclado 4×3 defina 4 filas y 3 columnas.

#include <Keypad.h>
const byte row_count = 4;
const byte column_count = 3;

A continuación, defina qué caracteres o números quiere imprimir cuando se pulse un botón concreto del teclado.

Los caracteres están dispuestos tal y como aparecen en el teclado.

Puede definir qué caracteres se imprimen al pulsar un botón.

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

Ahora define los pines de Arduino que quieres conectar a un teclado 4×4. 

byte row_pins[row_count] = {12, 11, 10, 9};

byte column_pins[column_count] = {8, 7, 6, 5};

A continuación, utilice la función de la biblioteca.

Teclado = Keypad( makeKeymap(keys), rowpin, columnpin, ROW, COLUMN );

Este constructor define un objeto Keypad de la clase Keypad y lo inicializa. 

rowpin y columnpin :- La configuración de pines en Arduino UNO a la que se conectan las filas y columnas del teclado.

La función makeKeymap(keys) se utiliza para inicializar el mapa de teclas interno para que sea igual al mapa de teclas definido por el usuario según las claves definidas anteriormente.

Keypad myKeypad = Keypad(makeKeymap(keys4x3), row_pins, column_pins, row_count, column_count);

En la función void setup(), configuro el puerto serie a una velocidad de 9600 baudios para mostrar la clave procesada a través del monitor serie del IDE de Arduino utilizando la función Serial.begin(). El LED incorporado se define como salida y se establece como bajo.

En el bucle void(), se utiliza la función keypad.getKey() para escanear y obtener la tecla pulsada. La visualización de la salida en el monitor serie utiliza la función Serial.println().

Al pulsar "D" en el teclado 4×4 o "#" en el teclado 4×3, el LED permanecerá encendido durante 2 segundos.

 if (key_value == password) 
    {
      Serial.println("LED ON");
      digitalWrite(13, HIGH);
      delay(2000);
      digitalWrite(13, LOW);    
    }

-> Lee nuestro artículo sobre ¿Es fácil aprender Arduino?

Sistema de bloqueo con contraseña mediante teclado

Esta sección le proporcionará un código para almacenar su contraseña en la EEPROM y le permitirá cambiar su contraseña y restablecerla.

Tenga en cuenta que la interconexión del circuito seguirá siendo la misma que la de 4×4.

Tenga en cuenta que la interconexión del circuito seguirá siendo la misma que la de 4x4
#include <Keypad.h>
#include <EEPROM.h>

char new_pass[4], user_input_pass[4], eeprom_pass[4];
int i = 0;

char key_def, key_pass;
char default_pass[4] = "2468"; //set the defaul password here

const byte row_count = 4;
const byte column_count = 4;

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

byte row_pins[row_count] = {12, 11, 10, 9};
byte column_pins[column_count] = {8, 7, 6, 5};

Keypad myKeypad = Keypad(makeKeymap(keys4x4), row_pins, column_pins, row_count, column_count);

void setup()
{
  Serial.begin(9600);
  Serial.println("Please Follow the Menu\nPress A to Compare Password\nPress B to Change Password\nPress C to Set Default password\n");
  Serial.println("Press C If you are using code first time");
}
void loop()
{
  key_def = myKeypad.getKey();

  switch (key_def)
  {
    case 'A':
      Serial.print("Enter The Password:");
      while (i < 4)
      {
        key_pass = myKeypad.getKey();
        if (key_pass)
        {
          user_input_pass[i++] = key_pass;
          Serial.print(key_pass);
        }
        key_pass = 0;
      }
      if (i == 4)
      {
        delay(200);
        for (int j = 0; j < 4; j++)
          eeprom_pass[j] = EEPROM.read(j);
        if (!(strncmp(user_input_pass, eeprom_pass, 4)))
        {
          Serial.println();
          Serial.println("Password  Accepted");
          //Write your logic for correct password
        }
        else
        {
          Serial.println();
          Serial.println("Wrong Password...");
        }
        i = 0;
      }
      break;

    case 'B': 
      Serial.println("Change your Password:");
      change();
      break;

    case 'C': 
      reset_password();
      Serial.println("Set Default Password Done....");
      break;

  }
}

void change()
{
  int j = 0;
  Serial.println("Please Enter Your Current Password");
  while (j < 4)
  {
    char key = myKeypad.getKey();
    if (key)
    {
      user_input_pass[j++] = key;
      Serial.print(key);
    }
    key = 0;
  }
  delay(500);

  if ((strncmp(user_input_pass, eeprom_pass, 4)))
  {
    Serial.println();
    Serial.println("Wrong Password!");
    Serial.println("Try Again!");
    delay(1000);

    key_def = 0;
  }
  else
  {
    j = 0;
    Serial.println();
    Serial.println("Enter New Password:");
    while (j < 4)
    {
      char key = myKeypad.getKey();
      if (key)
      {
        new_pass[j] = key;
        Serial.print(key);
        EEPROM.write(j, new_pass[j]);
        j++;
      }
    }
    Serial.println();
    Serial.println("Password Successfully Updated...");
    delay(1000);
  }
}

void reset_password() {
  strncpy(eeprom_pass, default_pass, 4);
  for (int j = 0; j < 4; j++) {
    EEPROM.write(j, default_pass[j]);
  }
}

Cómo funciona el código

This code can be used to set the password and store it in the EEPROM. You need to include #include <EEPROM.h> in your code to use the EEPROM library. 

En el void setup(), se imprimirá el menú, y no olvides establecer la tasa de baudios como 9600 en tu monitor serial.

En void loop(), he utilizado tres casos diferentes para la configuración de la contraseña.

El caso A se utiliza para comparar la contraseña introducida por el usuario con la contraseña almacenada en la EEPROM.

El caso B se utiliza para cambiar la contraseña existente almacenada en la EEPROM.

El caso C se utiliza para restablecer la contraseña, y la contraseña por defecto "2468" se va a almacenar en la EEPROM.

void change() se utiliza para cambiar la contraseña actual y establecer una nueva contraseña. Esta función es llamada cuando se presiona la tecla B.

void reset_password() se utiliza para establecer la contraseña por defecto. Esta función es llamada cuando se presiona la tecla C. 

EEPROM.write(address, value) se utiliza para escribir contraseñas en la memoria EEPROM.

EEPROM.write(j, new_pass[j]);

EEPROM.write(j, default_pass[j]);

EEPROM.read(address) se utiliza para leer el valor almacenado en una dirección determinada. 

strncpy(char *dest, const char *src, size_t n)

Strncpyy se utiliza para copiar la contraseña del origen al destino.

strncpy(eeprom_pass, default_pass, 4);

strncmp(const char *str1, const char *str2, size_t n)

Strncmp se utiliza para comparar las dos cadenas de contraseñas para que la MCU pueda identificar si la contraseña introducida es correcta o no.

 if ((strncmp(user_input_pass, eeprom_pass, 4))

Salida de monitor en serie:

Salida de monitorización en serie

Proyectos Arduino basados en teclados:

->Consulta nuestra guía de los 12 mejores cursos online de Arduino

Conclusión

En este artículo has aprendido a utilizar los teclados 4×4 y 4×3 con las placas Arduino. 

Además, también he explicado cómo se puede almacenar la contraseña en la EEPROM de la placa Arduino y cómo cambiar la contraseña.

Espero que este artículo le haya resultado informativo. Si es así, ¡compártalo con un amigo al que le guste la electrónica y hacer cosas!

Me encantaría saber qué proyecto tienes pensado construir o has hecho ya con el Keypad y Arduino.

Si tienes alguna pregunta o sugerencia, o si crees que faltan cosas en este tutorial, deja un comentario a continuación.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.