Programación de Semáforos con Arduino y Sensores

Curso Fundamentos de Desarrollo de Hardware con Arduino

Contenido del curso

Bienvenida al curso

Introducción al hardware libre

Sensores, Actuadores y Procesadores

Introducción a la electrónica

Manos a la obra

Automatización de procesos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:002:09

Programación de Semáforos con Arduino y Sensores

Curso Fundamentos de Desarrollo de Hardware con Arduino

Clase 32 de 38

Clase 32 / 38

Recursos

Domina el control de semáforos con Arduino combinando PWM, sensores analógicos y botones peatonales. Pon en práctica entradas y salidas, condicionales, ciclos y estructuras de datos en un escenario real: un crucero con flujo en dos sentidos y prioridades claras para peatones y coches.

¿Qué vas a construir con Arduino: semáforos con peatones?

Vas a programar un par de semáforos que controlan un crucero sobre una avenida principal donde confluyen dos avenidas adicionales. Hay flujo en ambos sentidos y los coches deben poder incorporarse hacia el norte o sur según definas. Además, debes integrar botones para que las personas puedan solicitar cruce.

Control de un crucero con dos sentidos de circulación y accesos.
Incorporación de coches a la vía principal con reglas claras.
Botones para peatones que avisan cuándo alguien quiere cruzar.
Definición de tiempos y prioridades entre peatones y coches.
Uso de varias condiciones y ciclos para la lógica de control.

¿Cómo integrar botones peatonales con Arduino?

Los botones sirven para avisar que hay peatones esperando. Tu lógica debe considerar ese evento y ajustar el flujo vehicular.

Leer el estado del botón y detectar solicitud de cruce.
Ajustar el orden de luces según la relevancia dada al peatón.
Evitar bloqueos y asegurar que cada solicitud tenga respuesta.

¿Cómo definir el algoritmo y los tiempos del semáforo?

Tu decisión sobre qué tiene prioridad impacta la experiencia de ambos: peatón y coche. Diseña una secuencia coherente y justa.

Establecer reglas de paso para cada sentido.
Decidir tiempos para verde, amarillo y rojo según tu criterio.
Incluir casos especiales cuando hay o no solicitudes de cruce.

¿Cómo aplicar condicionales, ciclos y estructuras de datos?

El reto exige traducir reglas del tráfico a lógica de programa. Si ya programas o cursaste algoritmos con C, estás listo para abordar estas decisiones; si no, conviene reforzar condicionales, ciclos y estructuras antes de implementarlo.

Usar condicionales para cambiar estados según entradas y tiempos.
Implementar ciclos para ejecutar la secuencia de luces de forma continua.
Representar estados y eventos con estructuras de datos simples.
Diseñar una lógica clara que evite conflictos en el cruce.

¿Qué habilidades y conceptos necesitas dominar?

Este reto integra lo aprendido para operar el hardware y la lógica de control. Cada elemento es clave para que el sistema sea seguro, claro y eficiente.

Entradas y salidas: lectura de botones y control de luces.
PWM: ajuste fino de intensidad si decides graduar luces.
Sensores analógicos: lectura de valores continuos cuando corresponda.
Condicionales: decisiones según solicitudes y estados.
Ciclos: repetición de la secuencia del semáforo.
Estructuras de datos: manejo ordenado de estados y eventos.
Algoritmo: reglas que definen tiempos y prioridades.
Botones peatonales: evento que desencadena el cruce seguro.
Semáforos: control coordinado de luces para cada vía.
Crucero y avenida principal: contexto con múltiples incorporaciones.
Flujo de autos: circulación en dos sentidos que no debe colisionar.
Relevancia: prioridad otorgada a peatones o coches en tu diseño.

¿Listo para mostrar resultados? Comparte tu programa y el video en YouTube, y cuéntanos en comentarios cómo resolviste los tiempos y la prioridad entre peatones y coches.

Nicolas Pennisi

Hace 8 años

Por poco cumplo el reto 😅😅 Comparto mi código, Arduino y diagrama de flujo. Necesitaría una pista, si no es molestia. Armé estos semáforos basados en el sistema que vi en L.A., que cuando un peatón aprieta el botón, todos los semáforos se ponen en rojo y los peatones pueden cruzar para cualquier lado.

Usé 2 Leds RGB para simular el semáforo principal, 2 Leds azules para simular las luces de giro y 2 blancos para simular la luz de los peatones. La idea es que, como no me alcanzan los pines digitales, cada uno cumple la función los 2 semáforos de la avenida (que están enfrentados).

Mi problema es que quiero que cuando se apriete un botón, el programa espere a que el Led termine su acción y luego pase al sistema de peatón. En el sentido que no se apriete el botón y pase automáticamente al modo de peatones. Y si alguno sabe, estaría agradecido que me diera aunque sea una pista para después yo averiguar por mí mismo.

Me encantó el curso hasta ahora!!

Usé el Monitor Serial para hacer controles nada más.

//p refiere a la avenida principal, mientras que s refiere a la avenida secundaria
constint redP = 11;
constint greenP = 10;
constint blueP = 9;;
constint peatonP = 13;
constint giroP = 12;

constint redS = 7;
constint greenS = 6;
constint blueS = 5;
constint peatonS = 3;
constint giroS = 4;

constint button = 2;
int button_value; 
int button_pressed = LOW;

long previousTime = 0;

int semaforo = 0;

long semaforo_rojo_verde = 16000;
long semaforo_peatones = 16000;
long semaforo_giro = 6000;
long semaforo_amarillo = 2000;

voidsetup() 
{
  pinMode(redP, OUTPUT);
  pinMode(greenP, OUTPUT);
  pinMode(blueP, OUTPUT);
  pinMode(peatonP, OUTPUT);
  pinMode(giroP, OUTPUT);

  pinMode(redS, OUTPUT);
  pinMode(greenS, OUTPUT);
  pinMode(blueS, OUTPUT);
  pinMode(peatonS, OUTPUT);
  pinMode(giroS, OUTPUT);

  pinMode(button, INPUT_PULLUP);

  Serial.begin(9600);
 
}

voidloop() 
{
  button_value = digitalRead(button);
  unsignedlong currentTime = millis();

//En esta cadena de if se van apagando y prendiendo LEDs siguiendo un orden especifico para simular la actuacion de los semaforos en la calle
//currentTime = previousTime es necesario porque, una vez que se supera el tiempo que se quiere, la accion queda. Si esta igualdad no estuviera, la accion se repetiria todo el tiempo. Es un if, no un while\
//El tiempo que se fija a superar en los if se refiere al de la duracion del if anterior. En el caso 0 se refiere al 10
//Estructura en los digitalWrite:
// 1 - Leds que pasan a HIGH y Leds que pasan a LOW, tienen un delay de 100, haciendo de cuenta que pasarian a ser otro Led mas o que el RGB va a cambiar de color, y pasan de vuelta a HIGH
// 2 - Leds que permanecen en HIGH
// 3 - Leds que pasan a LOW
// 4 - Leds que permanecen en LOW 

  if(semaforo == 0)
  {
    if (currentTime - previousTime > semaforo_amarillo)
    {
      previousTime = currentTime;
      semaforo++;
      
      digitalWrite(redP, HIGH);
      digitalWrite(giroP, HIGH);
      digitalWrite(redS, HIGH);
      
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);
      digitalWrite(giroS, LOW);

      Serial.println("0");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 1)
  {
    if (currentTime - previousTime > semaforo_giro)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(giroP, LOW);
      delay(100);
      digitalWrite(giroP, HIGH);  

      digitalWrite(redP, HIGH);
      digitalWrite(redS, HIGH);
      
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);
      digitalWrite(giroS, LOW);

      Serial.println("1");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 2)
  {
    if (currentTime - previousTime > semaforo_giro)
    {
      previousTime = currentTime;
      semaforo++;    
      digitalWrite(redP, LOW);
      delay(100);
      digitalWrite(redP, HIGH);
      digitalWrite(greenP, HIGH);

      digitalWrite(redS, HIGH);

      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);
      digitalWrite(giroS, LOW);

      Serial.println("2");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 3)
  {
    if (currentTime - previousTime > semaforo_amarillo)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(greenP, LOW);
      delay(100);
      digitalWrite(greenP, HIGH);
      digitalWrite(peatonP, HIGH);
      
      digitalWrite(redS, HIGH);
      
      digitalWrite(redP, LOW);
      
      digitalWrite(blueP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);
      digitalWrite(giroS, LOW);

      Serial.println("3");
      Serial.println(currentTime);
    }
  }    
  if(semaforo == 4)
  {
    if (currentTime - previousTime > semaforo_rojo_verde)
    {
      previousTime = currentTime;
      semaforo++;     
      digitalWrite(greenP, LOW);
      delay(100);
      digitalWrite(greenP, HIGH);
      digitalWrite(redP, HIGH);

      digitalWrite(redS, HIGH);
 
      digitalWrite(peatonP, LOW);
      
      digitalWrite(blueP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);
      digitalWrite(giroS, LOW);
      
      Serial.println("4");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 5)
  {
    if (currentTime - previousTime > semaforo_amarillo)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(redP, LOW);
      delay(100);
      digitalWrite(redP, HIGH);
      digitalWrite(giroS, HIGH);
      digitalWrite(giroS, HIGH);
      
      digitalWrite(redS, HIGH);

      digitalWrite(greenP, LOW);
      
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);


      Serial.println("5");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 6)
  {
    if (currentTime - previousTime > semaforo_giro)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(giroS, LOW);
      delay(100);
      digitalWrite(giroS, HIGH);

      digitalWrite(redP, HIGH);
      digitalWrite(redS, HIGH);
      
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);

      Serial.println("6");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 7)
  {
    if (currentTime - previousTime > semaforo_giro)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(redS, LOW);
      delay(100);  
      digitalWrite(redS, HIGH);
      digitalWrite(greenS, HIGH);

      digitalWrite(redP, HIGH);

      digitalWrite(giroS, LOW);
      
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(peatonS, LOW);

      Serial.println("7");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 8)
  {
    if (currentTime - previousTime > semaforo_amarillo)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(greenS, LOW);
      delay(100);  
      digitalWrite(greenS, HIGH);
      digitalWrite(peatonS, HIGH);

      digitalWrite(redP, HIGH);

      digitalWrite(redS, LOW);
            
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(giroS, LOW);

      Serial.println("8");
      Serial.println(currentTime);
    }
  }
  if(semaforo == 9)
  {
    if (currentTime - previousTime > semaforo_rojo_verde)
    {
      previousTime = currentTime;
      semaforo++;
      digitalWrite(greenS, LOW);
      delay(100);
      digitalWrite(greenS, HIGH);  
      digitalWrite(redS, HIGH);

      digitalWrite(redP, HIGH);

      digitalWrite(peatonS, LOW);
      
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(peatonP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(giroS, LOW);

      Serial.println("9");
      Serial.println(currentTime);
    }
  }
  if(semaforo > 9)
  {
    semaforo = 0;
  }

  
  if (button_value == LOW && button_pressed == LOW)
  {
      digitalWrite(redP, HIGH);
      digitalWrite(peatonP, HIGH);
      digitalWrite(redS, HIGH);
      digitalWrite(peatonS, HIGH);
      
      digitalWrite(greenP, LOW);
      digitalWrite(blueP, LOW);
      digitalWrite(giroP, LOW);
      digitalWrite(greenS, LOW);
      digitalWrite(blueS, LOW);
      digitalWrite(giroS, LOW);
      
      delay(semaforo_peatones);

      Serial.println("boton");
      Serial.println(currentTime);
      button_pressed = HIGH;
  }
  if (button_value == HIGH && button_pressed == HIGH)
  {
    button_pressed = LOW;
  }
}

Nicolas Pennisi

Hace 8 años

Emanuel Moreno Manriquez

Hace 6 años

Como solo quieres una pista intenta usar while y goto para forzar las rutas del diagrama de flujo para que no tengas que leer todas las situaciones en cada ciclo.

Comentarios (24)24 comentarios

Pablo Cesar Cardozo Chile

Hace 9 años

Jhon Carlos Romo Ramirez

Youssef Abarca

Helmut Iván Dubón González

Hace 4 años

Jonathan Macalupu Reyes

Ricardo Celis

Profesor

Jorge Gens Abujas

Jeffry Andrés López Garita

José Manuel Robles Espinosa

Hace 3 años

Aldo Sandoval

César Romero

Alexis Antonio Moraga Gallardo

Carlos Alberto Quiñonez Tellez

Jose Antonio Padron Fernandez

Marcel Nahir Samur

Gerardo Castro

Andrés Leonardo Mogollón Benavides

Korpi delfin

Fernando Arango Orozco

Hace 7 años

Jess Key

Hace 2 meses

Jaime de Jesús Meza Estrada

Hace 7 meses

David Santiago Medina Puerto

Marcelo Rodrigo Duran Mamani

Joaquim Jair Merlo Luque

José Enrique Durán Granados

Ricardo Portillo

Bienvenida al curso

Servidor Web Asíncrono con ESP8266 y Arduino

Fundamentos de Desarrollo de Hardware con Arduino

Introducción al hardware libre

Arduino: Desarrolla Prototipos Interactivos con Microcontroladores

Desarrollo de Prototipos de Hardware: Diseño y Fabricación

Diseño Mecánico de Hardware con SolidWorks y Herramientas Paramétricas

Desarrollo de Interfaces y Prototipos con QT en Sistemas Embebidos

Limitaciones de Arduino en productos finales

Selección de Arduino para Envío de Datos a Servidor

Fundamentos de Desarrollo de Hardware con Arduino

Proyectos con Arduino: Componentes y Materiales Necesarios

Sensores, Actuadores y Procesadores

Sensores y Actuadores: Fundamentos para Automatización con Arduino

Cómo los robots ven a través de sensores

Tipos de Sensores y sus Aplicaciones en Robótica y Electrónica

Clasificación y Aplicaciones de Actuadores en la Industria

Introducción a la electrónica

Conceptos básicos de electricidad y electrónica para Arduino

Resistencias y capacitores en electrónica básica

Componentes Electrónicos Básicos: LEDs, Transistores y Circuitos Integrados

Uso de la Ley de Ohm para Conectar LEDs sin Quemarlos

Manos a la obra

Conociendo los Puertos y Alimentación del Arduino Uno

Funcionamiento de la Protoboard para Prototipado Electrónico

Programación Básica en Arduino: Primeros Pasos con LED y Código

Declarar variables para pines de Arduino

Creación y Uso de Librerías en Arduino

Uso del Potenciómetro para Control de LED con Arduino

Comunicación Serial en Arduino: Uso del Monitor Serial

Cómo PWM simula voltaje analógico

Cómo Arduino simplifica el PWM

Uso de Botones con Resistencia Pull-Up en Arduino

Monitor temperatura con Arduino y LM35

Cálculo del Multiplicador para Convertir Lecturas de Sensor a Celsius

LCD 16x2 con Arduino sin conexión PC

Programación de Semáforos con Arduino y Sensores

Automatización de procesos

Motores con Arduino y puente H L293D

Cómo funciona un servomotor con Arduino

Potenciómetro controla servomotor en Arduino

Proyecto: Construcción y Programación de un Robot de Evasión de Obstáculos

Programación de Funciones de Control de Movimiento en Arduino

Robot sensor Pololu: lógica inversa y ciclo while

Programación de Semáforos con Arduino y Sensores