Los teclados son una forma estupenda de permitir que los usuarios interactúen con tu proyecto. Puedes utilizarlos para navegar por los menús, introducir contraseñas y controlar juegos y robots.

En este tutorial, te mostraremos cómo configurar un teclado en Arduino. Primero explicaremos cómo el Arduino detecta las pulsaciones de las teclas, luego te mostraremos cómo encontrar el pinout de cualquier teclado. Como ejemplo sencillo, verás cómo imprimir las pulsaciones de teclas en el monitor de serie y en una pantalla LCD. Finalmente, te mostraremos cómo activar un relé de 5V cuando una contraseña es introducida correctamente.

En este artículo usaremos un teclado de membrana de matriz 4X4, pero también hay códigos y diagramas de cableado para teclados de matriz 3X4. Lo bueno de los teclados de membrana es que son delgados y tienen un adhesivo que permite pegarlos a la mayoría de las superficies planas. También puedes conseguir teclados de estilo telefónico que tienen botones más gruesos. Incluso los teclados rescatados de teléfonos antiguos funcionan con Arduino.

En este tutorial aprenderás

    ¿Cómo funcionan los teclados?

    Los botones de un teclado están dispuestos en filas y columnas. Un teclado 3X4 tiene 4 filas y 3 columnas, y un teclado 4X4 tiene 4 filas y 4 columnas:

    Debajo de cada tecla hay un interruptor de membrana. Cada interruptor de una fila está conectado a los demás interruptores de la fila mediante una traza conductora debajo de la almohadilla. Cada interruptor de una columna está conectado de la misma manera: un lado del interruptor está conectado a todos los demás interruptores de esa columna mediante una traza conductora. Cada fila y columna se lleva a un solo pin, para un total de 8 pines en un teclado 4X4

    Al pulsar un botón se cierra el interruptor entre un trazo de columna y uno de fila, permitiendo que la corriente fluya entre un pin de columna y otro de fila.

    El siguiente esquema de un teclado 4X4 muestra cómo se conectan las filas y las columnas

    El Arduino detecta qué botón se ha pulsado detectando el pin de fila y columna que está conectado al botón.

    Esto ocurre en cuatro pasos:

    1. En primer lugar, cuando no se pulsa ningún botón, todos los pines de la columna se mantienen en HIGH, y todos los pines de la fila se mantienen en LOW:

    2. Cuando se pulsa un botón, el pin de la columna se pone en LOW ya que la corriente de la columna HIGH fluye hacia el pin de la fila LOW

    3. El Arduino ya sabe en qué columna está el botón, así que ahora sólo tiene que encontrar la fila en la que está el botón. Esto lo hace cambiando cada uno de los pines de la fila a HIGH, y al mismo tiempo leyendo todos los pines de la columna para detectar qué pin de la columna vuelve a HIGH

    4. Cuando el pin de la columna vuelve a HIGH, el Arduino ha encontrado el pin de la fila que está conectado al botón

    En el diagrama anterior, se puede ver que la combinación de la fila 2 y la columna 2 sólo puede significar que se ha pulsado el botón número 5

    Conecta el teclado al Arduino

    La disposición de los pines de la mayoría de los teclados de membrana es la siguiente:

    Sigue los siguientes diagramas para conectar el teclado a un Arduino Uno, dependiendo de si tienes un teclado 3X4 o 4X4

    ¿Cómo encontrar la distribución de pines del teclado?

    Si la disposición de los pines de tu teclado no coincide con los anteriores, puedes sondear los pines para averiguarlo. Tendrás que construir un circuito de prueba conectando un LED y una resistencia limitadora de corriente al Arduino (o a cualquier fuente de alimentación de 5V) de la siguiente manera

    En primer lugar, averigua pines del teclado están conectadas a las filas de botones. Inserta el cable de tierra (negro) en los primeros pines de la izquierda. Pulsa cualquier botón de la fila 1 y mantenlo pulsado. Ahora pon el cable positivo (rojo) en cada uno de los otros pines. Si el LED se enciende en una de las patillas, mantén pulsado otro botón de la fila 1 y vuelve a poner el cable positivo en cada uno de los pines. Si el LED se enciende en otro pin, significa que el cable de tierra está insertado en el pin de la fila 1. Si ninguno de los botones de la fila 1 hace que el LED se encienda, el cable de tierra no está conectado a la fila 1. Ahora mueve el cable de tierra hasta el siguiente pin, pulsa un botón en una fila diferente y repite el proceso anterior hasta que hayas encontrado el pin de cada fila.

    Para averiguar a qué pines están conectadas las columnas, pon el cable de tierra en el pin que sabes que es la fila 1. Ahora mantén pulsado cualquiera de los botones de esa fila. Nuevamente pon el cable positivo en cada uno de los pines restantes. El pin que hace que el LED se ilumine es el pin que está conectado a la columna de ese botón. Ahora presiona otro botón de la misma fila, e inserta el cable positivo en cada uno de los otros pines. Repite este proceso para cada una de las otras columnas hasta que tengas cada una de ellas mapeada.

    Programando el teclado

    Para una demostración básica de cómo configurar el teclado, te mostraremos cómo imprimir cada pulsación de tecla en el monitor serie.

    Instalar la librería

    Usaremos la librería Keypad de Mark Stanley y Alexander Brevig. Esta librería se encarga de configurar los pines y de sondear las diferentes columnas y filas. Para instalar la librería Keypad, ve a Sketch > Include Library > Manage Libraries y busca “keypad”. Haz clic en la biblioteca y luego en instalar.

    El código de un teclado 4×4

    Una vez instalada la librería Keypad, puedes cargar este código en el Arduino si estás usando un teclado 4X4:

    #include <Keypad.h>
    
    const byte ROWS = 4; 
    const byte COLS = 4; 
    
    char hexaKeys[ROWS][COLS] = {
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };
    
    byte rowPins[ROWS] = {9, 8, 7, 6}; 
    byte colPins[COLS] = {5, 4, 3, 2}; 
    
    Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
    
    void setup(){
      Serial.begin(9600);
    }
    
    void loop(){
      char customKey = customKeypad.getKey();
      if (customKey){
        Serial.println(customKey);
      
    }
    

    El código de un teclado 3×4

    Si utilizas un teclado 3X4, puede utilizar este código

    #include <Keypad.h>
    
    const byte ROWS = 4; 
    const byte COLS = 3; 
    
    char hexaKeys[ROWS][COLS] = {
      {'1', '2', '3'},
      {'4', '5', '6'},
      {'7', '8', '9'},
      {'*', '0', '#'}
    };
    
    byte rowPins[ROWS] = {9, 8, 7, 6}; 
    byte colPins[COLS] = {5, 4, 3};
    
    Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 
    
    void setup(){
      Serial.begin(9600);
    }
    
    void loop(){
      char customKey = customKeypad.getKey();
      if (customKey){
        Serial.println(customKey);
      }
    }
    

    Las líneas 3 y 4 del código anterior establecen el número de filas y columnas del teclado.

    Las líneas 6-11 definen qué caracteres se imprimen cuando se pulsa un botón del teclado. Los caracteres están dispuestos tal y como aparecen en el teclado. Si tu teclado tiene una disposición diferente, puedes definir qué caracteres se imprimen al pulsar un botón. Por ejemplo, digamos que tu teclado tiene una columna de letras a la izquierda en lugar de a la derecha. Sólo tienes que cambiarlo por esto:

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

    Después de cargar el código, abre el monitor serie. Al pulsar una tecla, se imprimirá el valor:

    Usando un LCD con el teclado

    Ahora vamos a ver cómo imprimir las pulsaciones de las teclas en un LCD. Los teclados 4X4 usan 8 pines y los 3X4 usan 7 pines. Eso ocupa un montón de pines, así que voy a utilizar un LCD habilitado para I2C porque sólo necesita 4 cables para conectarse al Arduino.

    Instalar la librería liquidcrystal_I2C

    Para utilizar una pantalla LCD habilitada para I2C en Arduino, tendrás que instalar la biblioteca LiquidCrystal I2C por Marco Schwartz. Esta librería es buena porque incluye la mayoría de las funciones disponibles en la librería LiquidCrystal estándar. Para instalarla, descarga el archivo ZIP de abajo, y luego ve a Sketch > Incluir biblioteca > Añadir biblioteca .ZIP:

    Circuit Basics ZIP Icon LiquidCrystal I2C.zip

    La librería Wire

    La librería Wire es necesaria para añadir soporte a la comunicación I2C. Viene empaquetada con el IDE de Arduino, por lo que no es necesario instalarla. Pero si por alguna razón no está instalada en tu sistema, ve a Sketch > Include Library > Manage Libraries y busca “wire” para instalarla.

    Conecta el teclado y el LCD

    Una vez instaladas las librerías, conecta los pines de tierra y Vcc del LCD al Arduino, luego conecta los pines SDA y SCL del LCD de acuerdo a la siguiente tabla para las diferentes placas Arduino:

    Luego conecta el teclado al Arduino. Debería ser algo así (para un Arduino Uno)

    Código para la salida a una LCD

    Una vez que todo esté conectado, sube este código al Arduino

    #include <Wire.h> 
    #include <LiquidCrystal_I2C.h>
    #include <Keypad.h>
    
    const byte ROWS = 4;
    const byte COLS = 4;
    
    char hexaKeys[ROWS][COLS] = {
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };
    
    byte rowPins[ROWS] = {9, 8, 7, 6};
    byte colPins[COLS] = {5, 4, 3, 2};
    
    Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
    
    LiquidCrystal_I2C lcd(0x21, 16, 2); 
     
    void setup(){
      lcd.backlight();
      lcd.init(); 
    }
    
    void loop(){
      char customKey = customKeypad.getKey();
      if (customKey){
        lcd.clear();
        lcd.setCursor(0, 0); 
        lcd.print(customKey);
      }
    }

    Tendrás que añadir la dirección I2C de su LCD en la línea 20:

    LiquidCrystal_I2C lcd(0x21, 16, 2);

    La dirección I2C de mi LCD es 0x21, pero la tuya probablemente será diferente. La dirección I2C de tu LCD debería estar en la hoja de datos, pero si no, puedes encontrarla ejecutando este sketch I2C_Scanner.


    Usar una contraseña para activar un relé.


    Una de las aplicaciones más útiles de un teclado es utilizarlo para ingresar una contraseña. Puedes establecer una contraseña y hacer que el Arduino active un relé o algún otro módulo si la contraseña es correcta. El siguiente código activará un relé de 5V cuando la contraseña se introduzca correctamente:

    #include <Wire.h> 
    #include <LiquidCrystal_I2C.h>
    #include <Keypad.h>
    
    #define Password_Length 8 
    
    int signalPin = 12;
    
    char Data[Password_Length]; 
    char Master[Password_Length] = "123A456"; 
    byte data_count = 0, master_count = 0;
    bool Pass_is_good;
    char customKey;
    
    const byte ROWS = 4;
    const byte COLS = 4;
    
    char hexaKeys[ROWS][COLS] = {
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };
    
    byte rowPins[ROWS] = {9, 8, 7, 6};
    byte colPins[COLS] = {5, 4, 3, 2};
    
    Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
    
    LiquidCrystal_I2C lcd(0x21, 16, 2);  
    
    void setup(){
      lcd.init(); 
      lcd.backlight();
      pinMode(signalPin, OUTPUT);
    }
    
    void loop(){
    
      lcd.setCursor(0,0);
      lcd.print("Enter Password:");
    
      customKey = customKeypad.getKey();
      if (customKey){
        Data[data_count] = customKey; 
        lcd.setCursor(data_count,1); 
        lcd.print(Data[data_count]); 
        data_count++; 
        }
      if(data_count == Password_Length-1){
        lcd.clear();
    
        if(!strcmp(Data, Master)){
          lcd.print("Correct");
          digitalWrite(signalPin, HIGH); 
          delay(5000);
          digitalWrite(signalPin, LOW);
          }
        else{
          lcd.print("Incorrect");
          delay(1000);
          }
        
        lcd.clear();
        clearData();  
      }
    }
    
    void clearData(){
      while(data_count !=0){
        Data[data_count--] = 0; 
      }
      return;
    }

    Puedes cambiar la contraseña en la línea 10 sustituyendo el texto 123A456 por tu propia contraseña:


    char Master[Password_Length] = “123A456”;


    La longitud de la contraseña debe establecerse en la línea 5:

    define Password_Length 8

    La contraseña del ejemplo anterior sólo tiene 7 caracteres, pero la longitud de la contraseña es en realidad uno mayor que 7 porque hay un carácter nulo añadido al final de la cadena. Por ejemplo, si tu contraseña tiene 5 caracteres, introducirías 6 para la longitud de la contraseña.


    El pin de salida que activa el relé se define en la línea 7:

    int signalPin = 12;


    Después de conectar todo al Arduino, deberías tener algo parecido a esto:

    Pues eso es todo. No es difícil configurar un teclado en absoluto. Con un poco de ensayo y error deberías ser capaz de modificar el código anterior para que funcione con la mayoría de los proyectos para los que querrías usar un teclado.

    Krishna Pattabiraman. How to set up a keypad on an arduino. Circuit Basics. https://www.circuitbasics.com/how-to-set-up-a-keypad-on-an-arduino/