Control de ventilador, servomotor y led con un menú en el monitor serial.

Este proyecto es una inmersión profunda en la electrónica embebida y la interacción hombre-máquina (HMI), llevando el concepto de control más allá del Monitor Serial al incorporar un teclado matricial de 4×4. El objetivo es construir un sistema de menú robusto que permita al usuario controlar tres actuadores fundamentales —un LED, un ventilador de 12V y un servomotor— con solo presionar teclas físicas. Este enfoque no solo simplifica la interacción para el usuario final, sino que también obliga al programador a dominar la lógica de matrices de teclado y la máquina de estados.

🔩Funcionamiento

El objetivo de este proyecto es crear un menú principal en un Arduino que permita controlar un ventilador, un LED y un servomotor mediante el monitor serial. A continuación se detallan las opciones y funciones del menú.

El Corazón Lógico: La Placa Arduino UNO

El Arduino UNO actúa como el cerebro central, orquestando toda la lógica del sistema. Su función primordial es ejecutar la máquina de estados que define la navegación del menú, interpretar las señales enviadas por el teclado matricial y generar los comandos de salida específicos (digitales o PWM) para cada actuador. Es, en esencia, el traductor que convierte la presión de una tecla en una acción física.

La Interfaz de Usuario: El Teclado Matricial 4×4

El teclado matricial de 4×4 es nuestra principal herramienta de entrada, reemplazando al Monitor Serial. Funciona bajo el principio de la multiplexación, utilizando solo 8 pines del Arduino (4 filas y 4 columnas) para detectar 16 posibles combinaciones de teclas. Su función es proporcionar una entrada física, rápida y confiable al sistema. La tecla especial, el símbolo ‘#’, se configurará como la tecla de “Escape” o “Regresar al Menú Principal”, una característica crucial para la navegación.

El Indicador Lumínico: El Diodo LED

El LED, conectado a un pin digital, es el actuador más sencillo. Sirve como la prueba de fuego de las salidas digitales del Arduino, confirmando al instante que el comando de software (presionar una tecla) se traduce en un efecto físico de conmutación simple (encendido/apagado). Para proteger el LED, se debe utilizar una resistencia limitadora de corriente en serie con su cátodo (pata corta) antes de conectarlo a tierra.

El Músculo de Posición: El Servomotor

El servomotor es un motor especializado que permite un control preciso del ángulo de giro (típicamente entre 0∘ y 180∘). En este proyecto, su función es demostrar la gestión de una entrada numérica de múltiples dígitos a través de la interfaz del teclado. En lugar de encendido/apagado, el usuario ingresará un número (ejemplo: 155) y el motor se posicionará exactamente en ese ángulo, mediante una señal de Modulación por Ancho de Pulso (PWM) generada por el Arduino.

El Controlador de Potencia: Módulo de Relé y Ventilador de 12V

El módulo de relé es esencial para controlar el ventilador de 12V, ya que el Arduino solo puede manejar 5V y corrientes muy bajas. El relé sirve como un interruptor electromecánico de aislamiento galvánico:

• Protección: Aísla el circuito de control de baja tensión (5V) del circuito de potencia de 12V del ventilador.
• Conmutación: El Arduino envía una señal de activación (LOW o HIGH) al relé, que a su vez energiza un electroimán interno para cerrar físicamente el circuito de 12V, encendiendo o apagando el ventilador. El ventilador requiere su propia fuente de alimentación de 12V.

☰Menú

Menú Principal

Menú ventilador

1. Encender ventilador
2. Apagar ventilador

Menú led

1. Encender led
2. Apagar led

Menú servomotor

1. Introduce el ángulo

_🔨Componentes

🔌Conexiones

Conexión del teclado 4×4:

• Fila 1 del teclado matricial a pin 9 del Arduino.
• Fila 2 del teclado matricial a pin 8 del Arduino.
• Fila 3 del teclado matricial a pin 7 del Arduino.
• Fila 4 del teclado matricial a pin 6 del Arduino.
• Fila 5 del teclado matricial a pin 5 del Arduino.
• Fila 6 del teclado matricial a pin 4 del Arduino.
• Fila 7 del teclado matricial a pin 3 del Arduino.
• Fila 8 del teclado matricial a pin 2 del Arduino.

Conexiones del Rele:

• Conecta la entrada del relé (IN) al pin 11 de la placa Arduino.
• Conecta el pin VCC del relé al pin de 5V de la placa Arduino.
• Conecta el pin GND del relé al pin GND de la placa Arduino.
• Conecta el ventilador a la fuente de alimentación(5v) y al relé(común y normalmente cerrado).

Conexiones del Servo:

• Conecta la entrada del servo(IN) al pin 10 de la placa Arduino.
• Conecta el pin VCC del servo al pin de 5V de la placa Arduino.
• Conecta el pin GND del servo al pin GND de la placa Arduino.

Conexión del LED:

• Conecta el LED al pin 12 del Arduino y al GND, usando una resistencia 330 ohmios.

0️⃣Código

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#include <Arduino.h>
#include <Keypad.h>
#include <Servo.h>

  void fanMenu();
  void ledMenu();
  void servoMenu();
  void mainMenu();
  void handleMainMenu(char);

const byte ROWS = 4; // Cuatro filas
const byte COLS = 4; // Cuatro columnas

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

byte rowPins[ROWS] = {9, 8, 7, 6}; // Conectar a las salidas de fila del teclado
byte colPins[COLS] = {5, 4, 3, 2}; // Conectar a las salidas de columna del teclado

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

int servoPin = 10;
int fanPin = 11;
int ledPin = 12;

void setup() {
  Serial.begin(9600);
  pinMode(fanPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  myservo.attach(servoPin);
  mainMenu();
}

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

void mainMenu() {  
  Serial.println();
  Serial.println("Menu Principal");  
  Serial.println();
  Serial.println("1: Ventilador");
  Serial.println("2: LED");
  Serial.println("3: Servomotor");
}

void handleMainMenu(char key) {
  switch (key) {
    case '1':
      fanMenu();
      break;
    case '2':
      ledMenu();
      break;
    case '3':
      servoMenu();
      break;
    default:
      mainMenu();
  }
}

void fanMenu() {
  Serial.println();
  Serial.println("Menu Ventilador");  
  Serial.println();
  Serial.println("1: Encender Ventilador");
  Serial.println("2: Apagar Ventilador");
  char key = keypad.waitForKey();
  switch (key) {
    case '1':
      digitalWrite(fanPin, HIGH);
      mainMenu();
      break;
    case '2':
      digitalWrite(fanPin, LOW);
      mainMenu();
      break;
    case '#':
      mainMenu();
      break;
  }
}

void ledMenu() {
  Serial.println();
  Serial.println("Menu Led");  
  Serial.println();
  Serial.println("1: Encender LED");
  Serial.println("2: Apagar LED");
  char key = keypad.waitForKey();
  switch (key) {
    case '1':
      digitalWrite(ledPin, HIGH);
      mainMenu();
      break;
    case '2':
      digitalWrite(ledPin, LOW);
      mainMenu();
      break;
    case '#':
      mainMenu();
      break;
  }
}

void servoMenu() {
  Serial.println();
  Serial.println("Menu Servo");  
  Serial.println();
  Serial.println("Ingrese el angulo:");
  String angleStr = "";
  char key;
  while ((key = keypad.waitForKey()) != '*') {
    if (key >= '0' && key <= '9') {
      angleStr += key;
      Serial.print(key);
    } else if (key == '#') {
      mainMenu();
      return;
    }
  }
  int angle = angleStr.toInt();
  myservo.write(angle);
  mainMenu();
}

🖌️Diseños

🎬Videos

📑Conclusión

El proyecto de implementar un menú de control jerárquico en Arduino, operado a través de un teclado matricial de 4×4, es una conclusión exitosa y fundamental en la electrónica de sistemas embebidos.

Se logró con éxito la integración bidireccional entre una interfaz de entrada física (el teclado) y un conjunto diverso de actuadores, lo que demuestra un dominio de los siguientes pilares técnicos:

1. Máquina de Estados Robusta: El uso de la variable estadoMenu resolvió el desafío principal de la navegación. Esto permitió que las mismas teclas numéricas (‘1’, ‘2’) ejecutaran acciones distintas (encender el ventilador o el LED) según el contexto del menú, garantizando un funcionamiento coherente y a prueba de errores.
2. Control de Hardware Diverso: El sistema gestionó simultáneamente la conmutación de bajo voltaje (LED), el control de potencia y aislamiento (ventilador de 12V con relé) y la modulación de ancho de pulso (PWM) para posicionamiento preciso (servomotor).
3. Lógica de Interfaz Avanzada: Se superó el reto de la entrada numérica de múltiples dígitos a través del teclado, esencial para el servomotor, y se implementó la tecla especial ‘#’ para garantizar una navegación intuitiva y un escape seguro al menú principal.

En resumen, este proyecto transforma el Arduino de una simple placa de pruebas a un verdadero centro de mando, sentando las bases prácticas para la construcción de prototipos de domótica o sistemas de control industrial que requieren interfaces físicas directas y seguras.