Cómo hacer un semáforo con Arduino

Si el “Blink” (parpadeo de un LED) es el “Hola Mundo” de Arduino, el semáforo es, sin duda, el segundo paso lógico en nuestro aprendizaje.

Aparentemente es sencillo: encender y apagar tres luces. Sin embargo, este proyecto es fundamental porque nos obliga a dejar de pensar en un solo elemento para pensar en una secuencia de estados.

En este tutorial vamos a montar un semáforo para coches estándar, gestionando los tiempos de cada luz (Verde, Amarillo y Rojo) y asegurándonos de que la transición entre ellos sea fluida y correcta.

Secuencias y tiempos

Un semáforo no es más que una máquina de estados muy sencilla que se repite en bucle infinito. No enciende luces “al azar”, sino que sigue un orden estricto para garantizar la seguridad.

La secuencia estándar que vamos a programar es la europea:

El reto aquí no es electrónico, sino de orden. Si encendemos el rojo sin apagar el verde, tendremos un problema conceptual. Debemos asegurarnos de que el microcontrolador gestiona las transiciones apagando el estado anterior antes de activar el siguiente.

Para este montaje vamos a necesitar gestionar 3 salidas digitales.

Esquema de conexión

El montaje es muy limpio. Vamos a conectar cada LED a un pin digital independiente.

LEDs del semáforo

Conectamos el ánodo de cada LED a su pin mediante una resistencia, y llevamos todos los cátodos al carril de GND.

El código

Vamos a escribir el código de una manera limpia y legible. Un error de principiante sería poner números de pines “a fuego” (hardcoded) dentro del loop. Nosotros vamos a usar constantes para que sea fácil de modificar.

Definición y setup

Definimos los pines y los configuramos como salida.

// Definición de pines
const int pinVerde = 11;
const int pinAmarillo = 12;
const int pinRojo = 13;

// Definición de tiempos (en milisegundos)
const int tiempoVerde = 5000;    // 5 segundos
const int tiempoAmarillo = 2000; // 2 segundos
const int tiempoRojo = 5000;     // 5 segundos

void setup() {
  // Configuramos los pines como salida
  pinMode(pinVerde, OUTPUT);
  pinMode(pinAmarillo, OUTPUT);
  pinMode(pinRojo, OUTPUT);
  
  // Nos aseguramos de empezar con todo apagado
  digitalWrite(pinVerde, LOW);
  digitalWrite(pinAmarillo, LOW);
  digitalWrite(pinRojo, LOW);
}

El bucle principal (loop)

Aquí implementamos la secuencia. La lógica es siempre la misma:

1. Encender el color actual.
2. Esperar el tiempo definido.
3. Apagar el color actual (limpieza).

void loop() {
  // --- FASE 1: VERDE ---
  digitalWrite(pinVerde, HIGH);   // Encendemos Verde
  delay(tiempoVerde);             // Esperamos
  digitalWrite(pinVerde, LOW);    // Apagamos Verde

  // --- FASE 2: AMARILLO ---
  digitalWrite(pinAmarillo, HIGH); // Encendemos Amarillo
  delay(tiempoAmarillo);           // Esperamos
  digitalWrite(pinAmarillo, LOW);  // Apagamos Amarillo

  // --- FASE 3: ROJO ---
  digitalWrite(pinRojo, HIGH);     // Encendemos Rojo
  delay(tiempoRojo);               // Esperamos
  digitalWrite(pinRojo, LOW);      // Apagamos Rojo
}

Refactorizando el código

El código anterior funciona, pero si quisiéramos añadir un semáforo para peatones, el loop se volvería kilométrico. Una buena práctica en programación es modularizar.

Vamos a crear una función para cambiar las luces. Esto hace que el loop se lea como si fuera lenguaje natural.

void loop() {
  cambiarLuz(pinVerde, tiempoVerde);
  cambiarLuz(pinAmarillo, tiempoAmarillo);
  cambiarLuz(pinRojo, tiempoRojo);
}

// Función auxiliar que agrupa la lógica
void cambiarLuz(int pin, int duracion) {
  digitalWrite(pin, HIGH); // Enciende
  delay(duracion);         // Espera
  digitalWrite(pin, LOW);  // Apaga y listo para el siguiente
}