¡Desbloquea Todo el Potencial de los Menús en Arduino con un Teclado Matricial 4×4 y Pantalla LCD 16×2!

En proyectos con Arduino, implementar un sistema de menú puede mejorar significativamente la interacción con el usuario. Al integrar un teclado matricial 4×4 y una pantalla LCD 16×2, se puede crear una interfaz intuitiva y funcional para controlar diversas opciones y funcionalidades. Este artículo te guiará a través del proceso de creación de un menú con Arduino utilizando un teclado matricial y una pantalla LCD, destacando los puntos clave y cómo sacar el máximo provecho de este tipo de interfaz.

Componentes Necesarios

Para este proyecto, necesitaremos los siguientes componentes:

• Arduino Uno (o similar)
• Pantalla LCD 16×2
• Módulo I2C
• Teclado Matricial 4×4

Pinout del proyecto

Conexiones del Teclado Matricial 4×4

El teclado matricial tiene 8 pines (4 para las filas y 4 para las columnas). En el código, estos se conectan de la siguiente manera:

• Fila 1 (pin 9 en Arduino)
• Fila 2 (pin 8 en Arduino)
• Fila 3 (pin 7 en Arduino)
• Fila 4 (pin 6 en Arduino)
• Columna 1 (pin 13 en Arduino)
• Columna 2 (pin 12 en Arduino)
• Columna 3 (pin 11 en Arduino)
• Columna 4 (pin 10 en Arduino)

Conexiones de la Pantalla LCD 16×2 con Interfaz I2C

La pantalla LCD se conecta mediante una interfaz I2C, que utiliza solo 4 conexiones:

• VCC: Conectar al pin 5V de Arduino.
• GND: Conectar a cualquier pin GND de Arduino.
• SDA: Conectar al pin A4 de Arduino (SDA – Data Line).
• SCL: Conectar al pin A5 de Arduino (SCL – Clock Line).

Resumen de Conexiones

Componente	Pin Arduino
Teclado Fila 1	9
Teclado Fila 2	8
Teclado Fila 3	7
Teclado Fila 4	6
Teclado Columna 1	13
Teclado Columna 2	12
Teclado Columna 3	11
Teclado Columna 4	10
LCD I2C VCC	5V
LCD I2C GND	GND
LCD I2C SDA	A4
LCD I2C SCL	A5

Estas conexiones permitirán que el teclado matricial 4×4 interactúe correctamente con el Arduino y la pantalla LCD 16×2, mostrando las opciones del menú y ejecutando las acciones seleccionadas a través del teclado. ¡Asegúrate de verificar bien las conexiones para evitar errores en el funcionamiento!

Configuración del Teclado Matricial 4×4 y Pantalla LCD 16×2

El primer paso en la implementación es configurar correctamente el teclado matricial y la pantalla LCD. En el código proporcionado, se utiliza la librería Keypad.h para manejar las entradas del teclado matricial y LiquidCrystal_I2C.h para controlar la pantalla LCD a través de la interfaz I2C.

El teclado 4×4 tiene una disposición de 16 teclas organizadas en una matriz de 4 filas por 4 columnas. Para configurarlo, se definen los pines correspondientes en el código:

// Pines asignados para las filas y columnas del teclado
byte pinesFilas[FILAS] = {9, 8, 7, 6};    // Pines 9 a 6 para las filas (izquierda a derecha)
byte pinesColumnas[COLUMNAS] = {13, 12, 11, 10};  // Pines 13 a 10 para las columnas (izquierda a derecha)

Las teclas del teclado se mapean a una matriz de caracteres que representa la disposición física:

// Mapeo de las teclas basado en la distribución observada
char teclas[FILAS][COLUMNAS] = {
  {'1', '4', '7', '*'},
  {'2', '5', '8', '0'},
  {'3', '6', '9', '#'},
  {'A', 'B', 'C', 'D'}
};

Esto permite detectar qué tecla se presiona y asociarla con una función específica en el menú.

Inicialización y Configuración de la Pantalla LCD

La pantalla LCD 16×2 es ideal para mostrar información del menú, opciones y mensajes al usuario. En este caso, se utiliza un módulo I2C para simplificar la conexión y reducir el número de pines necesarios:

// Crear el objeto lcd con la dirección 0x20 y 16 columnas x 2 filas
LiquidCrystal_I2C lcd(0x20, 16, 2);

La pantalla se inicializa y configura para mostrar el menú inicial en el setup():

void setup() {
  Serial.begin(9600);  // Inicializar el monitor serial para depuración
  lcd.init();          // Inicializar el LCD
  lcd.backlight();     // Encender la luz de fondo

  // Mostrar el menú inicial
  lcd.setCursor(0, 0);
  lcd.print("Seleccionar Menu");
  lcd.setCursor(0, 1);
  lcd.print("1. Opcion 1");
}

Implementación del Menú con Arduino Keypad

El menú se controla mediante la lectura de las teclas presionadas en el teclado. La función getKey() de la librería Keypad detecta cuando una tecla es presionada, y se utiliza un switch para manejar las diferentes opciones del menú:

void loop() {
  char tecla = teclado.getKey();

  if (tecla) {
    Serial.print("Tecla presionada: ");
    Serial.println(tecla);

    lcd.clear();  // Limpia la pantalla LCD antes de mostrar la nueva opción
    switch(tecla) {
      case '1':
        lcd.setCursor(0, 0);
        lcd.print("Opcion 1");
        lcd.setCursor(0, 1);
        lcd.print("Mensaje 1");
        break;
      case '2':
        lcd.setCursor(0, 0);
        lcd.print("Opcion 2");
        lcd.setCursor(0, 1);
        lcd.print("Mensaje 2");
        break;
      case '3':
        lcd.setCursor(0, 0);
        lcd.print("Opcion 3");
        lcd.setCursor(0, 1);
        lcd.print("Mensaje 3");
        break;
      case 'A':
        lcd.setCursor(0, 0);
        lcd.print("Menu Principal");
        lcd.setCursor(0, 1);
        lcd.print("1. Opcion 1");
        break;
      default:
        lcd.setCursor(0, 0);
        lcd.print("Tecla no valida");
        delay(1000);  // Espera para mostrar el mensaje de error
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Seleccionar Menu");
        lcd.setCursor(0, 1);
        lcd.print("1. Opcion 1");
        break;
    }
  }
}

Cada caso dentro del switch representa una opción del menú. Por ejemplo, al presionar ‘1’, el programa mostrará «Opción 1» en la primera línea del LCD y un mensaje específico en la segunda. Si se presiona una tecla no válida, se muestra un mensaje de error y el menú principal se vuelve a mostrar.

Puntos Clave para Considerar

1. Asignación de Pines Correcta: Asegúrate de que los pines del teclado matricial estén correctamente asignados en el código para que cada tecla se mapee correctamente a su función.
2. Inicialización del LCD: La pantalla debe inicializarse correctamente, y el backlight debe estar encendido para que sea visible.
3. Gestión de Menú y Teclas: Utiliza estructuras condicionales o un switch para manejar las diferentes opciones del menú basadas en la entrada del teclado.
4. Depuración: Utiliza Serial.print para depurar y asegurarte de que las teclas presionadas corresponden a las opciones del menú esperadas.

Simulación Con TinkerCad

A continuación, te dejamos la simulación en Tinkercad, donde podrás ver las conexiones y el código completo. Esta simulación te permitirá realizar pruebas y ajustes antes de montar el circuito físicamente.

• Para ver el código: haz clic en el botón «Código».
• Para correr la simulación: haz clic en «Iniciar simulación».

En el menú de esta simulación, las teclas activas son la 1, 2, y 3. Puedes aprovechar estas teclas para realizar otras acciones una vez seleccionadas, como mostrar mensajes adicionales en la pantalla LCD, encender una luz, activar un motor, o cualquier otra funcionalidad que desees implementar.

Implementar un menú con un teclado matricial y una pantalla LCD en Arduino no solo hace que tus proyectos sean más interactivos, sino que también proporciona una excelente oportunidad para aprender sobre la integración de hardware y software en sistemas embebidos. Si estás en México y necesitas componentes electrónicos, como los diodos que hemos usado aquí, te invitamos a visitar nuestra tienda de electrónica en la CDMX. ¡Te esperamos con todo lo que necesitas para tus proyectos!

¡Comienza a experimentar y desbloquea todo el potencial de tu Arduino con un sistema de menú fácil de usar!