La verdad No Aprendí Mucho =(
Bienvenida al curso
Enlaces del taller IoT
Qué aprenderás sobre el desarrollo de hardware con Arduino
Introducción al hardware libre
¿Qué es Arduino y qué placas hay?
¿Cómo se desarrolla el Hardware?
¿Cuál es el software para diseño mecánico?
Elección del software a utilizar
Limitaciones de Arduino y qué es el hardware libre
Reto 1: Para un proyecto de IoT, ¿Cuál tarjeta Arduino utilizarías?
¿Cómo funciona el Curso de Desarrollo de Hardware con Arduino?
Lista de Materiales o Componentes a Utilizar
Sensores, Actuadores y Procesadores
Sensores, actuadores y procesadores
Diferentes tipos de sensores según la salida
Diferentes tipos de sensores según la aplicación
Diferentes tipos de actuadores
Introducción a la electrónica
Diferencias entre electricidad y electrónica
Tipos de componentes electrónicos
Más tipos de componentes electrónicos
Limitando la corriente para evitar quemar un led
Manos a la obra
Puertos de un arduino y sus funciones
Qué es un protoboard
Estructura general de un programa en Arduino y hello world con un LED
Variables y Constantes Globales
Manejo de librerías y funciones
Manejo de valores analógicos: uso del potenciómetro
Uso del monitor serial
PWM y señales analógicas
Un control de color RGB e intensidad lumínica para una lampara de mesa
Uso de push buttons
Monitor de temperatura con Arduino (uso de LM35 y un lcd 16x2)
Continuando con el monitor de temperatura con Arduino
Finalizando con el monitor de temperatura con Arduino
Reto: Crea tu semáforo con Arduino
Automatización de procesos
Cómo generar movimiento y uso de motores
Cómo generar movimiento y servomotores
Agregando un potenciométro para controlar la posición del Servomotor
Robot evasor de obstáculos
Continuando con el Robot evasor de obstáculos
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
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.
Aportes 13
Preguntas 2
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;
}
}```

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.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.