Bienvenida al curso

1

Enlaces del taller IoT

2

Qué aprenderás sobre el desarrollo de hardware con Arduino

Introducción al hardware libre

3

¿Qué es Arduino y qué placas hay?

4

¿Cómo se desarrolla el Hardware?

5

¿Cuál es el software para diseño mecánico?

6

Elección del software a utilizar

7

Limitaciones de Arduino y qué es el hardware libre

8

Reto 1: Para un proyecto de IoT, ¿Cuál tarjeta Arduino utilizarías?

9

¿Cómo funciona el Curso de Desarrollo de Hardware con Arduino?

10

Lista de Materiales o Componentes a Utilizar

Sensores, Actuadores y Procesadores

11

Sensores, actuadores y procesadores

12

Diferentes tipos de sensores según la salida

13

Diferentes tipos de sensores según la aplicación

14

Diferentes tipos de actuadores

Introducción a la electrónica

15

Diferencias entre electricidad y electrónica

16

Tipos de componentes electrónicos

17

Más tipos de componentes electrónicos

18

Limitando la corriente para evitar quemar un led

Manos a la obra

19

Puertos de un arduino y sus funciones

20

Qué es un protoboard

21

Estructura general de un programa en Arduino y hello world con un LED

22

Variables y Constantes Globales

23

Manejo de librerías y funciones

24

Manejo de valores analógicos: uso del potenciómetro

25

Uso del monitor serial

26

PWM y señales analógicas

27

Un control de color RGB e intensidad lumínica para una lampara de mesa

28

Uso de push buttons

29

Monitor de temperatura con Arduino (uso de LM35 y un lcd 16x2)

30

Continuando con el monitor de temperatura con Arduino

31

Finalizando con el monitor de temperatura con Arduino

32

Reto: Crea tu semáforo con Arduino

Automatización de procesos

33

Cómo generar movimiento y uso de motores

34

Cómo generar movimiento y servomotores

35

Agregando un potenciométro para controlar la posición del Servomotor

36

Robot evasor de obstáculos

37

Continuando con el Robot evasor de obstáculos

38

Terminando con el Robot evasor de obstáculos

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Reto: Crea tu semáforo con Arduino

32/38
Recursos

Ya sabemos manejar entradas y salidas, el PWM de Arduino, a leer sensores analógicos.

Tu reto es escribir un programa de semáforos con Arduino, este par de semáforos son los encargados de manejar un crucero.

  • Cada crucero tiene un flujo de autos hacia los dos sentidos con la posibilidad de incorporarse a las vías principales.
  • Debes incorporar botones que permitan avisar que hay personas esperando a cruzar la calle.

Aportes 13

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

La verdad No Aprendí Mucho =(

este código utiliza sensores, para efectos prácticos utilizo dos pulsadores, cada que presiono un pulsador se realiza el cambio de semaforo

Intente hacer el código lo más simple y legible posible.
Los semáforos funcionan con 6 estados (cases 0 al 5), y cada estado tiene un tiempo de duración.

const int GREEN_MAIN_STREET = 3;
const int YELLOW_MAIN_STREET = 4;
const int RED_MAIN_STREET = 5;
const int BUTTON_MAIN_STREET = 6;

const int GREEN_SIDE_STREET = 7;
const int YELLOW_SIDE_STREET = 8;
const int RED_SIDE_STREET = 9;
const int BUTTON_SIDE_STREET = 10;

int waitTime = 0;

typedef struct {
  bool green;
  bool yellow;
  bool red;
} lights;

void setup()
{
  // put your setup code here, to run once:
  pinMode(GREEN_MAIN_STREET, OUTPUT);
  pinMode(YELLOW_MAIN_STREET, OUTPUT);
  pinMode(RED_MAIN_STREET, OUTPUT);
  pinMode(BUTTON_MAIN_STREET, INPUT_PULLUP);

  pinMode(GREEN_SIDE_STREET, OUTPUT);
  pinMode(YELLOW_SIDE_STREET, OUTPUT);
  pinMode(RED_SIDE_STREET, OUTPUT);
  pinMode(BUTTON_SIDE_STREET, INPUT_PULLUP);
}

void loop()
{
  lights mainStreet = {0, 0, 0};
  lights sideStreet = {0, 0, 0};
  // put your main code here, to run repeatedly:
  for (int i = 0; i < 6; i++)
  {
    switch (i)
    {
      case 0:
        mainStreet = {0, 0, 1};
        sideStreet = {0, 0, 1};
        waitTime = 20;
        break;

      case 1:
        mainStreet = {0, 0, 1};
        sideStreet = {1, 0, 0};   // Green light sideStreed
        waitTime = 40;
        break;

      case 2:
        mainStreet = {0, 0, 1};
        sideStreet = {0, 1, 0};
        waitTime = 10;
        break;

      case 3:
        mainStreet = {0, 0, 1};
        sideStreet = {0, 0, 1};
        waitTime = 10;
        break;

      case 4:
        mainStreet = {1, 0, 0};   // Green light mainStreed
        sideStreet = {0, 0, 1};
        waitTime = 40;
        break;

      case 5:
        mainStreet = {0, 1, 0};
        sideStreet = {0, 0, 1};
        waitTime = 10;
        break;
    }
    trafficLightMain(mainStreet);
    trafficLightSide(sideStreet);

    // Usamos un for para no usar un delay tan alto sino
    // particionar el tiempo en tiempos más pequeños
    // y cada cierto tiempo revisamos el estado de los botones
    // cuando exista la luz verde

    for (int t = 0; t < 100; t++)
    {
      if (i == 4 && digitalRead(BUTTON_MAIN_STREET) == LOW)
      {
        delay(1000);
        break;
      }
      if (i == 1 && digitalRead(BUTTON_SIDE_STREET) == LOW)
      {
        delay(1000);
        break;
      }
      delay(waitTime);
    }
  }
}

void trafficLightMain(lights value)
{
  digitalWrite(GREEN_MAIN_STREET, value.green);
  digitalWrite(YELLOW_MAIN_STREET, value.yellow);
  digitalWrite(RED_MAIN_STREET, value.red);
}

void trafficLightSide(lights value)
{
  digitalWrite(GREEN_SIDE_STREET, value.green);
  digitalWrite(YELLOW_SIDE_STREET, value.yellow);
  digitalWrite(RED_SIDE_STREET, value.red);
}

Cualquier sugerencia es bienvenida 😃

#include <LiquidCrystal.h>

int rojo1 = 2;
int verde1 = 4;
int rojo2 = 5;
int verde2 = 7;
int boton1 = 3;
int boton2 = 6;
int turno = 1;
int c;
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

void setup() {
  lcd.begin(16,2);
  pinMode(boton1, INPUT_PULLUP);
  pinMode(boton2, INPUT_PULLUP);
  pinMode(rojo1,OUTPUT);
  pinMode(verde1,OUTPUT);
  pinMode(rojo2,OUTPUT);
  pinMode(verde2,OUTPUT);
}

void loop() {
  if(turno == 1)
  {
    for( c = 5; c > 0 ; c--)
    {
      if(digitalRead(boton1) == LOW)
      {
        c = 0; 
      }
      digitalWrite(rojo1, LOW);
      digitalWrite(verde2, LOW);
      digitalWrite(verde1, HIGH);
      digitalWrite(rojo2, HIGH);
      lcd.setCursor(0,0);
      lcd.print("Verde");
      lcd.setCursor(0,1);
      lcd.print(c);
      delay(1000);
      lcd.clear();            
    }
    turno++;
  } else if(turno == 2)
  {
    for(c = 5; c > 0 ; c--)
    {
      if(digitalRead(boton2) == LOW )
      {
        c = 0; 
      }
      digitalWrite(verde1,LOW);
      digitalWrite(rojo2, LOW);
      digitalWrite(rojo1, HIGH);
      digitalWrite(verde2, HIGH);
      lcd.setCursor(0,0);
      lcd.print("Rojo");
      lcd.setCursor(0,1);
      lcd.print(c);
      delay(1000);
      lcd.clear();
    }
    turno = 1;
  }
  
}```


![](![123.png](https://static.platzi.com/media/user_upload/123-6cd09a84-660d-4ec1-8b6d-c001e07be3a8.jpg)

Buenas tardes compañeros y compañeras,
Comparto con ustedes el desafío de esta clase. He partido de algunas premisas para su construcción, las mismas se comentan en el código. Desde ya los invito a proponer sugerencias , cambios y optimizaciones al código.

He intentando aplicar todos los conocimientos adquiridos hasta ahora en la ruta de IoT. He usado distintos tipos variables, distintas estructuras de control y funciones.

Éxitos para todos!!

/********************************************
	Para el desarrollo de este desafío se han
se ha partido de las premisas enunciadas a
continuación:

1- Se considera, interpretando de los comentarios
del profesor, que los semáforos permiten ingresar 
a las avenidas secundarios solo saliendo por la 
derecha, más no por la izquierda (Practica muy 
empleada en la cuidad donde vivo). Mientras que 
desde las avenidas secundarias se puede ingresar
a la principal girando tanto a izquierda como a
derecha.

2- Esto nos deja con un sistema de semáforos de 3
movimientos. Una secuencia para la avenida principal
(en ambos sentidos) y dos secuencias independientes 
para cada avenida secundaria.

3- Se ha tomado como tiempo de espera para cada
semáforo 60s (35s en rojo, 15s en amarillo y 10s
en parpadeo amarillo). La luz verde se mantendrá 
estática por 50s y luego parpadeara por otros 10s.

4- Si un peatón pulsase el botón de cruce, deberá esperar
a que la secuencia en ejecución se detenga, y luego
tendrá 25s para cruzar la calle.

Reto: Crea tu semáforo con Arduino
Curso: Fundamentos de Desarrollo de Hardware con Arduino
Profesor: Ricardo Celis
Alumno: Marcel Nahir Samur
Fecha: 25/10/2020
********************************************************/


// Avenida ppal.
const int pr = 11;
const int pa = 10;
const int pv = 9;
const int pb = 8;

//Avenida sec. 1
const int s1r = 5;
const int s1a = 6;
const int s1v = 7;
const int s1b = 4;

//Avenida sec. 2
const int s2r = A1;
const int s2a = A2;
const int s2v = A3;
const int s2b = A0;

const int arrSem[9] = {pr, pa, pv, s1r, s1a, s1v, s2r, s2a, s2v}; // Arreglo de LEDs
const int alarmaPeaton = 13; //Alarma de peatones


//Duración de las luces (en Milisegundos)
unsigned int drs = 35000;
unsigned int das = 15000;
unsigned int dap = 10000;
unsigned int dbs = 25000;

bool btnFlag = false;
int status;

void setup()
{ 
  Serial.begin(9600);
  //Luces 
  for (int i = 0 ; i < 9 ; i++)
    pinMode(arrSem[i], OUTPUT);
  
  //Pulsadores
  pinMode(pb, INPUT_PULLUP);
  pinMode(s1b, INPUT_PULLUP);
  pinMode(s2b, INPUT_PULLUP);
  
  //Alarma
  pinMode(alarmaPeaton, OUTPUT);
  
}

void loop()
{
  // Los estados son 4, 3 p/circulacion vehicular y 1 para cruce de peatones
  status = 1;
  
  for (int j = 0 ; j < 3 ; j++) //Ejecutamos las 3 secuencias de semáforos
  {
  	secuencia();
    
    // Se evalua en cada iteración si algun peaton ha oprimido el pulsador
    if (btnFlag == true) 
    {
      	for (int k = 0 ; k < 9 ; k++)
        {
   		digitalWrite(arrSem[k], LOW); // Semáforos apagados
        }
    	digitalWrite(pr, HIGH);  //Todos los semáforos
    	digitalWrite(s1r, HIGH); // vehiculares
    	digitalWrite(s2r, HIGH); // en rojo
      	digitalWrite(alarmaPeaton, HIGH); // Semáforos peatonales
    	delay(dbs);
      	
      	status++; // Se pasa a la siguiente secuencia
      	btnFlag = false; // Se desactiva la señal peatonal
    }
    else
    {
      status++; // Se pasa a la siguiente secuencia
    }
  }
}

/* Se utiliza el parpadeo de los LEDs verde
   y amarillo para indicar un cambio de estado inminente*/
int atencion(int at1,int at2,int at3)
{
  for (int f = 0 ; f < 5 ; f++) // Para generar el parpadeo
  {
  digitalWrite(at1, LOW);
  digitalWrite(at2, LOW);
  digitalWrite(at3, HIGH);
  peaton(1000);
  digitalWrite(at1, HIGH);
  digitalWrite(at2, HIGH);
  digitalWrite(at3, HIGH);
  peaton(1000);
  }
}
// Estado de circulación libre o detención total
int estatico(int static1,int static2,int static3,int static4)
{
  digitalWrite(static1, HIGH);
  digitalWrite(static2, HIGH);
  digitalWrite(static3, HIGH);
  peaton(drs);
  digitalWrite(static3, LOW);
  digitalWrite(static4, HIGH);
  peaton(das);
}

/* Función para ejecutar los 3 posibles estados
   de los semáforos vehiculares */
int secuencia()
{
  for (int g = 0 ; g < 9 ; g++) 
    digitalWrite(arrSem[g], LOW); // Semáforos apagados
  
  switch (status)
  {
    case 1:
    	estatico(pv, s1r, s2r, s2a);
    	atencion(pv, s2a, s1r);
    	break;
    case 2:
    	estatico(s2v, pr, s1r, s1a);
    	atencion(s2v, s1a, pr);
    	break;
    case 3:
    	estatico(s1v, s2r, pr, pa);
    	atencion(s1v, pa, s2r);
    	break;
    default:
    	Serial.println("Error! Contacte a soporte técnico");
    	break;
  }
}

/* Se utiliza esta función para comprobar si un
   peaton ha pulsado el boton */
bool peaton(unsigned int dFrac)
{
  int dRes = 250; //Resolución, utilizado p/ dividir el retardo
  dFrac = dFrac/dRes;
  for (int dBtn = 0 ; dBtn < dFrac ; dBtn++)
  {
  	if (digitalRead(pb) == LOW || digitalRead(s1b) == LOW || digitalRead(s2b) == LOW)
  	{
    	btnFlag = true;
      	digitalWrite(alarmaPeaton, HIGH); 
    	delay(dRes);
  	}
  	else
    {
  		delay(dRes);
      	digitalWrite(alarmaPeaton, LOW); // Indicador de peatones apagado
    }
  }
  return btnFlag; // Se retorna el valor que se evaluará
}				  // en la función principal 

Aqui les dejo mi codigo! debo darle credito al companero Pablo Cardozo, me guie un poco de su coidgo para poder empezar pero le di mi propio enfoque y tambien copie el inicio donde aparece la descripcion, hacer eso es muy buena practica.

/**************************************************************
  Desafio#1 - Platzi
  Semáforo para dos Avenidas (Principal y Secundaria)
  ambas tienen una luz azul para indicar el giro a la
  izquierda y un pulsador peatonal para cambiar el 
  estado de la luz verde y darle paso a los peatones.
  
  Configuración:
    Entradas: botones de paso {A0(P),A1(S)} 
    Salidas: 
      luces verde, amarilla, roja y azul 
            {6,7,8,9}Princial ; {10,11,12,13}Secundaria
            cada LED esta conectado con una Resistencia de 220 Ohms
      Pantalla LCD
            RS = 0, E = 1, D4 = 2, D5 = 3, D6 = 4, D7 = 5;
            estamos utilizando para el LCD un potenciometro de 10 kOhms

  Autor: Gerardo Castro
  Fecha: 20.12.2018
**************************************************************/
#include <LiquidCrystal.h>


//VARIABLES GLOBALES.
unsigned int tiempo = 0; //En segundos. el cero no significa nada, solo esta siendo inicializada.
int peaton = 0;
unsigned long tiempoTimer;
int estadoPasado = 0;
int estadoActual = 0; //utilizaremos esto para asegurarnos de que todos los ciclos del semaforo se cumplan.
int estadoSiguiente = 1;

//SEMAFORO PRINCIPAL
const int verdP = 6;
const int amarP = 7;
const int rojoP = 8;
const int azulP = 9;
const int botP = A0;
int semPrin [4] = {verdP, amarP, rojoP, azulP};

//SEMAFORO SECUNDARIO
const int verdS = 10;
const int amarS = 11;
const int rojoS = 12;
const int azulS = 13;
const int botS = A1;
int semSec [4] = {verdS, amarS, rojoS, azulS};

LiquidCrystal lcd (0, 1, 2, 3, 4, 5);

//-------------------------------------------------//
//ESTRUCTURA ARDUINO
//-------------------------------------------------//

void setup() {
  // put your setup code here, to run once:
  lcd.begin(16,2);
  for (int i = 0;i < 4; i++){ //Definimos los pines del semaforo como output
    pinMode (semPrin[i], OUTPUT);
    pinMode (semSec[i], OUTPUT);
  }
  //Activamos los pullup resistors para los botones.
  pinMode (botP, INPUT_PULLUP);
  pinMode (botS, INPUT_PULLUP);
  iniciar();
}

void loop() {
  // put your main code here, to run repeatedly:
  if (timer(tiempo)){
    cambio();
  }
}

//-------------------------------------------------//
//-------------------------------------------------//

//*************************************************//
//TEMPORIZADOR
//*************************************************//
bool timer(int t){  
  tiempoTimer = (millis()/1000) + t;
  for(;(tiempoTimer - (millis()/1000)) >= 0;){
    boton();
    lcd.print(tiempoTimer - (millis()/1000));
    if((millis()%500 == 0)){//refrescamos la pantalla cada 1/2 segundo.
      lcd.clear();
      if(peaton == 1){
        lcd.clear();
        lcd.setCursor(0,1);
        lcd.print("Peaton Esperando");
      }
    }
    lcd.setCursor(0,0);
    if((tiempoTimer - (millis()/1000)) <= 4  && (tiempoTimer - (millis()/1000)) > 0){//Prendemos las luces amarillas cuando 
        digitalWrite(amarP, HIGH);
        digitalWrite(amarS, HIGH);
    }
    else if((tiempoTimer - (millis()/1000)) == 0){
      estadoPasado = estadoActual;
      return (1); //Devuelve TRUE una vez que el tiempo se agote.
    } 
  }
}

//*************************************************//
//STARTUP DEL SEMAFORO
//*************************************************//
void iniciar(){ //Simple Animacion al inicio del programa, puede ser eliminado.
  int t = 175;
  digitalWrite(verdP, HIGH);
  delay(t);
  digitalWrite(amarP, HIGH);
  digitalWrite(verdP, LOW);
  delay(t);
  digitalWrite(rojoP, HIGH);
  digitalWrite(amarP, LOW);
  delay(t);
  digitalWrite(azulP, HIGH);
  digitalWrite(rojoP, LOW);
  delay(t);
  digitalWrite(verdS, HIGH);
  digitalWrite(azulP, LOW);
  delay(t);
  digitalWrite(amarS, HIGH);
  digitalWrite(verdS, LOW);
  delay(t);
  digitalWrite(rojoS, HIGH);
  digitalWrite(amarS, LOW);
  delay(t);
  digitalWrite(azulS, HIGH);
  digitalWrite(rojoS, LOW);
  delay(t);
  digitalWrite(azulS, LOW);
  delay(t);
  for(int x = 0; x < 2; x++){
    for(int i = 0; i < 4; i++){
      digitalWrite(semPrin[i], HIGH);
      digitalWrite(semSec[i], HIGH);
    }
    delay(200);
    for(int i = 0; i < 4; i++){
      digitalWrite(semPrin[i], LOW);
      digitalWrite(semSec[i], LOW);
    }
    delay(200);
  }
  delay(1000);
}

//*************************************************//
//SECUENCIA DE CAMBIO DEL SEMAFORO
//*************************************************//
void cambio(){
  for(int i = 0; i < 4; i++){  //Apagamos todas las luces.
        digitalWrite(semPrin[i], LOW);
        digitalWrite(semSec[i], LOW);
  }
  switch(estadoSiguiente){//Definicion de cada caso posible de los semaforos. Recibe como parametro el siguiente estado del semaforo.
    case 0://Principal Verde, Secundario Rojo.
      tiempo = 90;
      digitalWrite(verdP, HIGH);
      digitalWrite(rojoS, HIGH);
      estadoActual = 0;
      estadoSiguiente = estadoActual + 1;
      break;
    case 1://Principal Rojo, Secundario Verde.
      tiempo = 60;
      digitalWrite(rojoP, HIGH);
      digitalWrite(verdS, HIGH);
      estadoActual = 1;
      estadoSiguiente = estadoActual + 1;
      break;
    case 2:// Principal Azul, Secundario Rojo.
      tiempo = 45;
      digitalWrite(azulP, HIGH);
      digitalWrite(rojoS, HIGH);
      estadoActual = 2;
      estadoSiguiente = estadoActual + 1;
      break;
    case 3:// Principal Rojo, Secundario Azul.
      tiempo = 30;
      digitalWrite(rojoP, HIGH);
      digitalWrite(azulS, HIGH);
      
      estadoActual = 3;
      estadoSiguiente = 0;
      break;
    }
  peaton = 0;
}

//*************************************************//
//COMPORTAMIENTO DEL BOTON. DETECCION DE PEATONES
//*************************************************//
void boton(){ 
      if (!digitalRead(botP)){
      if ((estadoActual == 0 || estadoActual == 2) && peaton == 0){//Verificamos que fluyan carros en la Av. Prin. y que solo se pueda presionar una vez el boton.
        if(estadoPasado == 3){
          estadoSiguiente = 1;
        }
        else if(estadoPasado == 1) {
          estadoSiguiente == 3;    
        }
        peaton = 1;
        if((tiempoTimer - (millis()/1000)) > 20){//acortamos el tiempo de espera.
          tiempoTimer = tiempoTimer - 15;
        }
      }
    }
    else if (!digitalRead(botS)){
      if ((estadoActual == 1 || estadoActual == 3) && peaton == 0){
        if(estadoPasado == 0){
          estadoSiguiente = 2;
        }
        else if(estadoPasado == 2) {
          estadoSiguiente == 0;
        }
        peaton = 1;
        if((tiempoTimer - (millis()/1000)) > 21){
          tiempoTimer = tiempoTimer - 15;
        }
      }
    }
}```

Imagen:

Código:
void loop() {
if(estado == 0){
digitalWrite(ledR1, HIGH);
digitalWrite(ledA1, LOW);
digitalWrite(ledV1, LOW);
digitalWrite(ledR0, LOW);
digitalWrite(ledA0, LOW);
digitalWrite(ledV0, HIGH);
if(digitalRead(boton0) == LOW){
digitalWrite(ledW1, HIGH);
digitalWrite(ledB0, LOW);
delay(tiempo);
digitalWrite(ledW1, LOW);
digitalWrite(ledB0, HIGH);
}
digitalWrite(ledB0, HIGH);
estado = 1;
ruta = true;
delay(tiempo);
}else if(estado == 1){
digitalWrite(ledR1, LOW);
digitalWrite(ledA1, HIGH);
digitalWrite(ledV1, LOW);
digitalWrite(ledB1, LOW);
digitalWrite(ledW1, LOW);
digitalWrite(ledR0, LOW);
digitalWrite(ledA0, HIGH);
digitalWrite(ledV0, LOW);
digitalWrite(ledB0, LOW);
if(ruta){estado = 2; }else{estado = 0;}
delay(tiempo-(tiempo*0.5));
}else{
digitalWrite(ledR1, LOW);
digitalWrite(ledA1, LOW);
digitalWrite(ledV1, HIGH);
digitalWrite(ledR0, HIGH);
digitalWrite(ledA0, LOW);
digitalWrite(ledV0, LOW);
digitalWrite(ledB0, LOW);
if(digitalRead(boton1) == LOW){
digitalWrite(ledB1, LOW);
digitalWrite(ledW0, HIGH);
delay(tiempo);
digitalWrite(ledW0, LOW);
}
digitalWrite(ledB1, HIGH);
estado = 1;
ruta = false;
delay(tiempo);
}

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;
  }
}

Me quede sin entradas pwd en el arduino. XD pero hize el código con 3 led. Lo voy a dejar para que pueda estudiarlo y si alguien cuenta con una placa más grande como la Arduino MEGA pueda terminarlo.


const int RETARDO_VERDE = 4000;
const int RETARDO_PARPADEO_VERDE = 500;
const int RETARDO_AMARILLO = 2000;
const int verde = 0;
const int amarillo = 1;
const int rojo = 2;
 int j = 0;
//configuración de led
int light[4][3] = {
  {2,3,4},
  {5,6,7},
  {8,9,10},
  {11,12,13},
};
    
  					
 
void setup() {

  for (int i = 0; i < 4; i++){
  	digitalWrite(light[i][verde],LOW);
  	digitalWrite(light[i][rojo],HIGH);
  	digitalWrite(light[i][amarillo],LOW);
  	pinMode(light[i][verde],OUTPUT);
  	pinMode(light[i][amarillo],OUTPUT);
  	pinMode(light[i][rojo],OUTPUT);
 }
}
 
void loop() {
  digitalWrite(light[j][verde],HIGH);
  digitalWrite(light[j][amarillo],LOW);
  digitalWrite(light[j][rojo],LOW);
  delay(RETARDO_VERDE);
  for(int i = 0; i < 6; i++) {
    if((i%2) == 0){ 
      digitalWrite(light[j][verde],HIGH);
    }else{
  		digitalWrite(light[j][verde],LOW);
    }
  	delay(RETARDO_PARPADEO_VERDE);
  }
  digitalWrite(light[j][amarillo],HIGH);
  delay(RETARDO_AMARILLO);
  digitalWrite(light[j][amarillo],LOW);
  digitalWrite(light[j][rojo],HIGH);
  j++;
  if(j>3){
    j=0;
  }
}```

como subo una imagen ?

#define LEDVERDE1 2
#define LEDAMARILLO1 3
#define LEDROJO1 4
#define LEDVERDE2 5
#define LEDAMARILLO2 6
#define LEDROJO2 7
#define PULSADOR1 8
#define PULSADOR2 9

// Variables
bool activo1 = true; // Indica si el semáforo 1 está activo, de lo contrario será el semáforo 2
int tiempoCambio = 500; // Tiempo de espera entre transición de LEDs
int tiempoEspera = 1000; // Tiempo de espera hasta comenzar transición

void setup() {
// Iniciamos el monitor serie
Serial.begin(9600);

// Modo entrada/salida de los pines
pinMode(LEDVERDE1, OUTPUT);
pinMode(LEDAMARILLO1, OUTPUT);
pinMode(LEDROJO1, OUTPUT);
pinMode(LEDVERDE2, OUTPUT);
pinMode(LEDAMARILLO2, OUTPUT);
pinMode(LEDROJO2, OUTPUT);
pinMode(PULSADOR1, INPUT);
pinMode(PULSADOR2, INPUT);

// Apagamos todos los LEDs
digitalWrite(LEDVERDE1, LOW);
digitalWrite(LEDAMARILLO1, LOW);
digitalWrite(LEDROJO1, LOW);
digitalWrite(LEDVERDE2, LOW);
digitalWrite(LEDAMARILLO2, LOW);
digitalWrite(LEDROJO2, LOW);

// Estado inicial: semáforo 1 abierto, semáforo 2 cerrado
digitalWrite(LEDVERDE1, HIGH);
digitalWrite(LEDROJO2, HIGH);
}

void loop() {
// Dependiendo del semáforo que tengamos activo
if (activo1)
{
// Está encendido el semáforo 1, comprobamos el pulsador 2
int valor2 = digitalRead(PULSADOR2);

// Si hay un coche esperando, pulsador pulsado
if (valor2 == HIGH)
{
  // Encender semáforo 2
  ecenderSemaforo2();

  // Semáforo 2 activo
  activo1 = false;
}

}
else
{
// Está encendido el semáforo 1, comprobamos el pulsador 1
int valor1 = digitalRead(PULSADOR1);

// Si hay un coche esperando, pulsador pulsado
if (valor1 == HIGH)
{
  // Encender semáforo 1
  ecenderSemaforo1();

  // Semáforo 1 activo
  activo1 = true;
}

}
}

void ecenderSemaforo2()
{
// Apagamos semáforo 1
// Esperamos
delay(tiempoEspera);

// Pasamos a luz amarilla
digitalWrite(LEDVERDE1, LOW);
digitalWrite(LEDAMARILLO1, HIGH);

// Esperamos
delay(tiempoCambio);

// Pasamos a luz roja
digitalWrite(LEDAMARILLO1, LOW);
digitalWrite(LEDROJO1, HIGH);

// Encendemos semáforo 2
// Esperamos
delay(tiempoCambio);

// Pasamos a luz amarilla
digitalWrite(LEDROJO2, LOW);
digitalWrite(LEDVERDE2, HIGH);
}

void ecenderSemaforo1()
{
// Apagamos semáforo 2
// Esperamos
delay(tiempoEspera);

// Pasamos a luz amarilla
digitalWrite(LEDVERDE2, LOW);
digitalWrite(LEDAMARILLO2, HIGH);

// Esperamos
delay(tiempoCambio);

// Pasamos a luz roja
digitalWrite(LEDAMARILLO2, LOW);
digitalWrite(LEDROJO2, HIGH);

// Encendemos semáforo 1
// Esperamos
delay(tiempoCambio);

// Pasamos a luz amarilla
digitalWrite(LEDROJO1, LOW);
digitalWrite(LEDVERDE1, HIGH);
}

Este lo diseñé en 8 tiempos 3 para los verdes 1 los amarillos y 4 los rojos, esto me permitió agrupar los casos posibles en 4 bloques y al final con un solo potenciometro se puede graduar el tiempo total que dura el el semáforo si afectar la escala 3V-1A-4R.

Para construir una interfaz para una tablet Android (o cualquier otro disposivo Touch), cual herramienta recomiendan.

Algo asi como esta imagen (.

Que curso pueden recomendar donde expliquen la interaccion de una pantalla touch con el arduino.

Muchas garcias de antemano.