Semáforo Inteligente con Arduino: Control de Tiempo por Botón y Radar de Velocidad por Fuerza

¿Alguna vez te has preguntado cómo funcionan los sistemas de tráfico inteligentes que vemos en las calles? Esos que reaccionan cuando un peatón presiona un botón o que detectan cuando un coche va demasiado rápido. ¡Hoy vas a construir el tuyo a escala!

En este tutorial paso a paso, vamos a llevar la programación con Arduino al siguiente nivel. No nos limitaremos a parpadear un par de luces; vamos a crear un sistema interactivo completo de seguridad vial.

🛠️ Componentes y su Distribución de Pines

Dado que tus módulos tienen placas de circuito integradas (por eso el botón, el zumbador y el sensor tienen 3 o 4 pines en lugar de los componentes sueltos), la regla general para los pines de 3 entradas es:

• VCC / + / V: Va al pin de 5V de Arduino.
• GND / – / G: Va al pin GND de Arduino.
• OUT / S / D: Es el pin de señal (va a los pines digitales o analógicos).

Aquí tienes el mapa exacto de conexiones:

Componente	Pin del Componente	Conexión en Arduino	Notas
Semáforo (4 pines)	GND	GND	Tierra común
	R (Rojo)	Pin Digital 4	Controla luz roja
	Y (Amarillo)	Pin Digital 3	Controla luz amarilla
	G (Verde)	Pin Digital 2	Controla luz verde
Botón Switch (3 pines)	VCC (+)	5V	Alimentación
	GND (-)	GND	Tierra
	OUT (S)	Pin Digital 5	Envía señal de pulsación
Sensor de Fuerza (3 pines)	VCC (+)	5V	Alimentación
	GND (-)	GND	Tierra
	OUT (S)	Pin Analógico A0	Envía un voltaje según la presión
Zumbador / Buzzer (3 pines)	VCC (+)	5V	Alimentación
	GND (-)	GND	Tierra
	OUT (S)	Pin Digital 6	Recibe la señal para sonar

⚠️ Nota sobre la alimentación: Como vas a conectar tres componentes a 5V y tres a GND, te recomiendo usar una protoboard (breadboard). Saca un cable desde el pin 5V de tu Arduino a la línea positiva (+) de la protoboard, y un cable desde GND a la línea negativa (-) de la protoboard. Así podrás alimentar todos los componentes fácilmente

💻 El Código de Arduino

Este código está optimizado y estructurado de forma limpia. Copia y pega esto en tu IDE de Arduino:.

// — DEFINICIÓN DE PINES —

const int PIN_ROJO = 4;

const int PIN_AMARILLO = 3;

const int PIN_VERDE = 2;

const int PIN_BOTON = 5;

const int PIN_FUERZA = A0; // Entrada analógica

const int PIN_ZUMBADOR = 6;

// — VARIABLES DE ESTADO —

// 1 = Rojo (Inicio), 2 = Amarillo, 3 = Verde, 0 = Apagado tras terminar

int estadoSemaforo = 1;

unsigned long tiempoUltimoCambio = 0;

bool secuenciaActiva = false; // Controla si la secuencia ya empezó

// Tiempo de espera de 8 segundos (8000 milisegundos)

const unsigned long INTERVALO = 8000;

// Umbral del sensor de fuerza (Ajustable)

const int UMBRAL_FUERZA = 600;

void setup() {

// Configuración de pines de salida

pinMode(PIN_ROJO, OUTPUT);

pinMode(PIN_AMARILLO, OUTPUT);

pinMode(PIN_VERDE, OUTPUT);

pinMode(PIN_ZUMBADOR, OUTPUT);

// Configuración de pines de entrada

pinMode(PIN_BOTON, INPUT);

// El semáforo inicia EN ROJO directamente

actualizarSemaforo();

// Iniciar monitor serie para calibración

Serial.begin(9600);

}

void loop() {

int lecturaBoton = digitalRead(PIN_BOTON);

// 1. Si se presiona el botón y la secuencia NO ha empezado, arranca el temporizador

if (lecturaBoton == HIGH && !secuenciaActiva) {

secuenciaActiva = true;

tiempoUltimoCambio = millis(); // Empieza a contar el tiempo desde este momento

delay(300); // Debounce para evitar falsos rebotes del botón

}

// 2. Control del ciclo del semáforo (Cambios cada 8 segundos)

if (secuenciaActiva) {

if (millis() – tiempoUltimoCambio >= INTERVALO) {

tiempoUltimoCambio = millis(); // Reinicia el temporizador para el siguiente color

estadoSemaforo++; // Pasa al siguiente estado (Rojo -> Amarillo -> Verde)

// Si pasa del Verde (3), reinicia todo al estado inicial (Rojo en espera)

if (estadoSemaforo > 3) {

estadoSemaforo = 1;

secuenciaActiva = false; // Detiene la secuencia hasta que se pulse el botón otra vez

noTone(PIN_ZUMBADOR); // Asegura que el zumbador quede apagado

}

actualizarSemaforo();

}

}

// 3. LÓGICA DEL ZUMBADOR: SOLO cuando el semáforo está en VERDE (Estado 3)

if (estadoSemaforo == 3) {

int valorFuerza = analogRead(PIN_FUERZA);

// Monitor serie para ver la fuerza real en verde

Serial.print(“Semáforo en VERDE. Fuerza actual: “);

Serial.println(valorFuerza);

// Suena si supera el límite de fuerza

if (valorFuerza > UMBRAL_FUERZA) {

tone(PIN_ZUMBADOR, 150); // Tono grave (150Hz)

} else {

noTone(PIN_ZUMBADOR); // Silencio si no se aplica suficiente fuerza

}

} else {

// Si no está en verde (está en Rojo o Amarillo), el zumbador permanece apagado

noTone(PIN_ZUMBADOR);

}

}

// — FUNCIONES AUXILIARES —

void apagarSemaforo() {

digitalWrite(PIN_ROJO, LOW);

digitalWrite(PIN_AMARILLO, LOW);

digitalWrite(PIN_VERDE, LOW);

}

void actualizarSemaforo() {

apagarSemaforo(); // Limpia los leds antes de encender el siguiente

switch (estadoSemaforo) {

case 1:

digitalWrite(PIN_ROJO, HIGH); // Encendido inicial o en espera

break;

case 2:

digitalWrite(PIN_AMARILLO, HIGH); // Cambia aquí a los 8 segundos de presionar el botón

break;

case 3:

digitalWrite(PIN_VERDE, HIGH); // Cambia aquí a los 16 segundos (8s después del amarillo)

break;

default:

apagarSemaforo();

break;

}

}

¡Hola! Qué gran proyecto tienes entre manos. Como programadora, te digo que este es un excelente ejercicio de sistemas embebidos: estamos combinando temporización (el semáforo), entrada digital (el botón), entrada analógica (el sensor de fuerza) y salida de audio (el zumbador).

Vamos a estructurar esto de forma impecable, paso a paso, para que no te pierdas en ningún cable ni en ninguna línea de código.

---

🛠️ Componentes y su Distribución de Pines

Dado que tus módulos tienen placas de circuito integradas (por eso el botón, el zumbador y el sensor tienen 3 o 4 pines en lugar de los componentes sueltos), la regla general para los pines de 3 entradas es:

• VCC / + / V: Va al pin de 5V de Arduino.
• GND / – / G: Va al pin GND de Arduino.
• OUT / S / D: Es el pin de señal (va a los pines digitales o analógicos).

Aquí tienes el mapa exacto de conexiones:

Componente	Pin del Componente	Conexión en Arduino	Notas
Semáforo (4 pines)	GND	GND	Tierra común
	R (Rojo)	Pin Digital 4	Controla luz roja
	Y (Amarillo)	Pin Digital 3	Controla luz amarilla
	G (Verde)	Pin Digital 2	Controla luz verde
Botón Switch (3 pines)	VCC (+)	5V	Alimentación
	GND (-)	GND	Tierra
	OUT (S)	Pin Digital 5	Envía señal de pulsación
Sensor de Fuerza (3 pines)	VCC (+)	5V	Alimentación
	GND (-)	GND	Tierra
	OUT (S)	Pin Analógico A0	Envía un voltaje según la presión
Zumbador / Buzzer (3 pines)	VCC (+)	5V	Alimentación
	GND (-)	GND	Tierra
	OUT (S)	Pin Digital 6	Recibe la señal para sonar

⚠️ Nota sobre la alimentación: Como vas a conectar tres componentes a 5V y tres a GND, te recomiendo usar una protoboard (breadboard). Saca un cable desde el pin 5V de tu Arduino a la línea positiva (+) de la protoboard, y un cable desde GND a la línea negativa (-) de la protoboard. Así podrás alimentar todos los componentes fácilmente.

---

💻 El Código de Arduino

Este código está optimizado y estructurado de forma limpia. Copia y pega esto en tu IDE de Arduino:

C++

// --- DEFINICIÓN DE PINES ---
const int PIN_ROJO = 4;
const int PIN_AMARILLO = 3;
const int PIN_VERDE = 2;

const int PIN_BOTON = 5;
const int PIN_FUERZA = A0; // Entrada analógica
const int PIN_ZUMBADOR = 6;

// --- VARIABLES DE ESTADO ---
int estadoSemaforo = 0; // 0 = Apagado/Espera, 1 = Rojo, 2 = Amarillo, 3 = Verde
unsigned long tiempoUltimoCambio = 0;
const unsigned long INTERVALO = 5000; // 5 segundos en milisegundos

// Umbral del sensor de fuerza (Ajustable)
// Los sensores analógicos miden de 0 a 1023. 
const int UMBRAL_FUERZA = 600; 

void setup() {
  // Configuración de pines de salida
  pinMode(PIN_ROJO, OUTPUT);
  pinMode(PIN_AMARILLO, OUTPUT);
  pinMode(PIN_VERDE, OUTPUT);
  pinMode(PIN_ZUMBADOR, OUTPUT);

  // Configuración de pines de entrada
  pinMode(PIN_BOTON, INPUT);
  // El pin analógico A0 no requiere pinMode estricto, pero es buena práctica

  // Iniciar semáforo apagado
  apagarSemaforo();
  
  // Iniciar monitor serie para calibración opcional
  Serial.begin(9600);
}

void loop() {
  int lecturaBoton = digitalRead(PIN_BOTON);

  // 1. Si el botón se presiona y el semáforo está apagado, inicia la secuencia
  if (lecturaBoton == HIGH && estadoSemaforo == 0) {
    estadoSemaforo = 1; // Pasa a Rojo
    tiempoUltimoCambio = millis(); // Registra el tiempo actual
    actualizarSemaforo();
    delay(300); // Pequeño debounce para evitar falsos rebotes del botón
  }

  // 2. Control del ciclo del semáforo (si ya está activo)
  if (estadoSemaforo > 0) {
    // Si han pasado 5 segundos, cambia al siguiente estado
    if (millis() - tiempoUltimoCambio >= INTERVALO) {
      tiempoUltimoCambio = millis(); // Reinicia el temporizador
      estadoSemaforo++;

      // Si pasa del Verde (3), vuelve a apagarse (0)
      if (estadoSemaforo > 3) {
        estadoSemaforo = 0;
        noTone(PIN_ZUMBADOR); // Asegurar que el zumbador se apague
      }
      
      actualizarSemaforo();
    }
  }

  // 3. Lógica del Sensor de Fuerza (SOLO cuando está en VERDE)
  if (estadoSemaforo == 3) {
    int valorFuerza = analogRead(PIN_FUERZA);
    
    // Imprime en el monitor serie para que puedas calibrar el sensor
    Serial.print("Valor de fuerza actual: ");
    Serial.println(valorFuerza);

    if (valorFuerza > UMBRAL_FUERZA) {
      // Tono grave: Frecuencia de 150Hz (puedes bajarla si la quieres más grave)
      tone(PIN_ZUMBADOR, 150); 
    } else {
      noTone(PIN_ZUMBADOR); // Silencio si no supera el límite
    }
  } else {
    // Si no está en verde, el zumbador debe estar apagado
    noTone(PIN_ZUMBADOR);
  }
}

// --- FUNCIONES AUXILIARES ---

void apagarSemaforo() {
  digitalWrite(PIN_ROJO, LOW);
  digitalWrite(PIN_AMARILLO, LOW);
  digitalWrite(PIN_VERDE, LOW);
}

void actualizarSemaforo() {
  apagarSemaforo(); // Apaga todo antes de encender el correcto

  switch (estadoSemaforo) {
    case 1:
      digitalWrite(PIN_ROJO, HIGH);
      break;
    case 2:
      digitalWrite(PIN_AMARILLO, HIGH);
      break;
    case 3:
      digitalWrite(PIN_VERDE, HIGH);
      break;
    case 0:
    default:
      apagarSemaforo();
      break;
  }
}

---

🔍 Explicación de la Lógica de Programación

¿Por qué este código es robusto y profesional?

• Uso de millis() en lugar de delay(): Si usáramos delay(5000) para los 5 segundos del semáforo, el Arduino se quedaría “congelado” y no podría leer el sensor de fuerza en tiempo real mientras el led verde está encendido. Con millis(), el Arduino revisa el sensor miles de veces por segundo mientras el tiempo corre de fondo.
• Máquina de Estados Simple: Usamos la variable estadoSemaforo (del 0 al 3) para que el programa sepa exactamente qué luz debe encender y si debe o no hacerle caso al sensor de fuerza.
• Calibración (UMBRAL_FUERZA): Los sensores de fuerza entregan valores entre 0 y 1023. En el código puse 600 como límite. Si abres el Monitor Serie en tu IDE de Arduino (Ctrl+Shift+M), verás los números reales que arroja tu sensor al presionarlo. Si ves que debes presionar muy fuerte para llegar a 600, baja ese número a 400 o 500.

🚀 Pasos para ponerlo en marcha

1. Realiza todas las conexiones con el Arduino desconectado de la computadora.
2. Conecta el Arduino por USB.
3. Abre el IDE de Arduino, pega el código, selecciona tu placa (ej. Arduino Uno) y el puerto correcto.
4. Presiona Subir (Upload).
5. Prueba el circuito: Presiona el botón $\rightarrow$ se enciende el rojo $\rightarrow$ a los 5s cambia a amarillo $\rightarrow$ a los 5s cambia a verde. Cuando esté en verde, presiona fuertemente el sensor de fuerza y escucharás el zumbido grave. A los 5s se apagará todo automáticamente.

En el mundo de la programación y la electrónica, es completamente normal que algo no funcione a la primera. De hecho, gran parte del trabajo de una programadora es hacer debugging (encontrar y solucionar fallos).

Aquí tienes la guía de solución de problemas (Troubleshooting) estructurada por síntomas para que puedas arreglar cualquier fallo en un abrir y cerrar de ojos:

---

🛑 Síntoma 1: Presiono el botón y no pasa absolutamente nada

Si el semáforo se queda completamente apagado tras pulsar el botón, el problema suele estar en la lectura digital.

• Causa 1: El botón está invertido. Muchos módulos de botones de 3 pines envían un LOW (0) cuando los presionas y un HIGH (1) cuando están en reposo (lógica invertida).
  • Solución: En el código, busca la línea:if (lecturaBoton == HIGH && estadoSemaforo == 0)Y cámbiala por:if (lecturaBoton == LOW && estadoSemaforo == 0)
• Causa 2: Pines cruzados (VCC y OUT). Si confundiste el pin de señal con el de voltaje, el Arduino no recibirá nada.
  • Solución: Revisa con una lupa las letras impresas en la placa del botón. Asegúrate de que el pin marcado como S, OUT o D vaya directo al Pin 5 del Arduino.

---

🚦 Síntoma 2: Las luces del semáforo no encienden (o encienden los colores equivocados)

Si el temporizador interno funciona pero las luces no responden como deberían.

• Causa 1: Cables de color intercambiados. * Solución: Desconecta el Arduino y verifica uno a uno. El pin R del módulo debe ir al pin 4, el Y al pin 3, y el G al pin 2. Si se enciende el verde en lugar del rojo, simplemente intercambia los cables en los pines digitales del Arduino.
• Causa 2: El módulo es de Cátodo Común o Ánodo Común. Algunos semáforos de kit funcionan al revés: se encienden cuando les envías un LOW y se apagan con un HIGH.
  • Solución: Si notas que el semáforo empieza con todas las luces encendidas y se van “apagando”, modifica las funciones del final del código. Cambia donde dice HIGH por LOW, y donde dice LOW por HIGH.

---

🔊 Síntoma 3: El zumbador no suena (o suena todo el tiempo)

El zumbador depende completamente de la lectura analógica del sensor de fuerza.

• Causa 1: El zumbador es “Pasivo” y no “Activo”. Los zumbadores pasivos necesitan una frecuencia para sonar (lo que hace nuestra función tone()), pero si es un zumbador activo de baja calidad, a veces frecuencias muy graves (como 150Hz) no lo hacen vibrar bien.
  • Solución: Sube la frecuencia en el código. Cambia tone(PIN_ZUMBADOR, 150); por una frecuencia más alta y aguda, por ejemplo, tone(PIN_ZUMBADOR, 1000); (1 kHz).
• Causa 2: El umbral de fuerza es muy alto o muy bajo. Si el zumbador suena siempre, el Arduino cree que estás presionando el sensor aunque no lo toques. Si no suena nunca, el número es muy alto.
  • Solución: Abre el Monitor Serie en el IDE de Arduino. Presiona el sensor con el dedo y mira qué números arroja. Si en reposo marca 100 y al presionarlo fuerte marca 400, tu umbral actual (600) es demasiado alto. Cambia la línea const int UMBRAL_FUERZA = 600; por const int UMBRAL_FUERZA = 300;.

---

⚡ Síntoma 4: El Arduino se reinicia o se apaga solo

Si al presionar el botón o sonar el zumbador el Arduino se desconecta de la computadora.

• Causa: Cortocircuito. Hay un cable de voltaje (5V o +) tocando directamente un cable de tierra (GND o -). Esto activa la protección de la computadora y apaga el puerto USB.
  • Solución: Desconecta el USB inmediatamente. Revisa la protoboard. Asegúrate de que las patas de los componentes o los cables pelados no se estén tocando entre sí. Verifica que ningún pin VCC de los módulos esté conectado a un GND del Arduino.

---

📝 Lista de verificación final (El “Checklist” de la Programadora)

Antes de volverte loca cambiando el código, haz este test rápido:

1. ¿El cable USB está bien conectado y el LED “ON” del Arduino está encendido en verde/rojo?
2. ¿Seleccionaste el puerto COM correcto en el menú Herramientas > Puerto del IDE de Arduino?
3. ¿Comparten todos los componentes la misma línea de GND? (Es vital para que las señales electrónicas tengan una referencia común).

¿Hay alguna parte específica del circuito que te esté dando problemas ahora mismo?

HECHO CON IA CON EL SIGUIENTE PROMPT

eres la mejor programadora del mundo. tienes un semaforo, un button swtch, un sensor de fuerza y un zumbador, todos pertenecientes a un kit de piezas para ardruino, quiero un tutorial bien hecho y muy bien especificado para que cuando oprimas el boton, el semaforo este en rojo y cada 5 segundos cambie a amarillo y luego a verde, cuando este en verde si el sensor de fuerza detecta mas fuerza de lo normal simulando la “velocidad” de un coche, el zumbador comenzara a sonar en tono grave anunciando que ha sobrepasado el limite de fuerza, este tutorial debe de tener todo lo necesario, el codigo para el arduino, los cables a donde van conectados, todo. El semaforo tiene 4 entradas, el button switch tiene 3 entradas, el sensor de fuerza tiene 3 entradas y el zumbador tambien tiene 3 entradas.