A
continuación expongo el bloque de programación y el montaje del automatismo de
un paso de peatones con semáforo accionado. Lo he realizado con una placa Arduino UNO y el bloque de programación lo he adaptado a
partir de un ejercicio práctico presente en la página 34 del siguiente manual:
El
programa se divide en varias partes o bloques, con el fin de establecer un orden
y una estructura. Así se hace más sencillo su entendimiento o la tarea de
buscar fallos.
La
primera actividad es asignar variables a las distintas luces que tenemos (salidas de
datos) y el botón de accionamiento del paso de peatones (entrada de datos),
pero sin hacer distinción de momento.
// Projecto: Semáforo interactivo para paso de peatones
int cochesRojo = 12; // asignación variable luz roja coches
int cochesAmarillo = 11; // asignación variable luz amarilla coches
int cochesVerde = 10; // asignación variable luz verde coches
int peatRojo = 9; // asignación luz roja peatones
int peatVerde = 8; //asignación luz verde peatones
int boton = 2; // asignación del pin 2 variable botón accionamiento
peatones
Seguidamente
declaramos la variable cruceTiempo
para permitir el paso de peatones durante 5 segundos.
También declaramos la variable cambioTiempo del tipo unsigned long para
guardar el instante en que termina el ciclo y la luz se vuelve a poner en verde
para los coches. Esto nos va a ser útil para evitar que el paso de peatones pueda ser accionando constantemente, bloqueando el paso de vehículos.
int cruceTiempo = 5000; // tiempo permitido para que el peatón
cruce
unsigned long cambioTiempo; // variable para guardar el tiempo
desde que hemos activado el paso para peatones
A continuación se
establece que variables son entradas o salidas.
void setup() {
pinMode(cochesRojo, OUTPUT); // asignación del pin 12 como salida
pinMode(cochesAmarillo, OUTPUT); // asignación del pin 11 como salida
pinMode(cochesVerde, OUTPUT); // asignación del pin 10 como salida
pinMode(peatRojo, OUTPUT); // asignación del pin 9 como salida
pinMode(peatVerde, OUTPUT); // asignación del pin 8 como salida
pinMode(boton, INPUT); // asignación del pin 2 como entrada
Arranca el ciclo son
los estados activos (HIGH)
de luz verde para vehículos y roja para peatones
digitalWrite(cochesVerde, HIGH);
digitalWrite(peatRojo, HIGH);
}
Para
poder accionar el paso de peatones necesitamos que se cumplan dos condiciones. Una
es que el botón de accionamiento haya sido pulsado. La otra es que, al menos, hayan
pasado 5 segundos desde la finalización del último ciclo. Y lo segundo, lo
realizamos gracias a la función millis().
void loop() {
int state =
digitalRead(boton);
if (state == HIGH &&
(millis() - cambioTiempo) > 5000) {
Una vez reunidas las
dos condiciones para poder accionar el paso de peatones, llamamos y definimos a
la función cambioLuces() que
se va a encargar de iniciar el ciclo secuencial.
cambioLuces();
}
}
void cambioLuces()
{
El
ciclo emula el funcionamiento habitual de este tipo de semáforos en España.
Para los vehículo se pasa de luz verde a roja, pasando 2 segundos por la
amarilla. Entonces, tras un segundo como tiempo de seguridad, el semáforo para
peatones pasa de rojo a verde. Los peatones tienen 5 segundos para pasar.
digitalWrite(cochesVerde, LOW); // apaga verde coches
digitalWrite(cochesAmarillo, HIGH); // enciende amarillo coches
delay(2000); // el ciclo se detiene 2 segundos
digitalWrite(cochesAmarillo, LOW); // apaga amarillo coches
digitalWrite(cochesRojo, HIGH); // enciende rojo coches
delay(1000); // el ciclo se detiene un segundo como precaución
digitalWrite(peatRojo, LOW); // apaga rojo peatones
digitalWrite(peatVerde, HIGH); // enciende verde peatones
delay(cruceTiempo); // el ciclo se detiene 5 segundos para que
peatón cruce
Antes
de pasar a rojo para los peatones, se inicia el parpadeo de la luz verde. Esto
lo ejecutamos mediante un bucle for que alterna el encendido y apagado de la
luz verde, a intervalos iguales de 5 segundos. Al final del bucle, la luz verde
queda en estado apagado (LOW).
for (int x=0; x<10; x++) {
digitalWrite(peatVerde, HIGH);
delay(250);
digitalWrite(peatVerde, LOW);
delay(250);
// al finalizar el bucle la luz verde peatones queda apagada
}
Y el ciclo termina de manera
secuencial volviendo al estado de luz verde para vehículos y roja para peatones,
con un intervalo de medio segundo entre medias.
digitalWrite(peatRojo, HIGH); // cambio a rojo para peatones
delay(500); // el siclo se detiene medio segundo
digitalWrite(cochesRojo, LOW); // apaga roja coches
digitalWrite(cochesVerde, HIGH); // enciende verde coches
Eso
sí, guardamos en la variable cambioTiempo
el instante, según el reloj, en el que terminó el ciclo. Esto nos permitirá
gestionar la espera mínima de 5 segundos antes de poder volver a accionar el
paso de peatones. Y volvemos al inicio del programa
cambioTiempo = millis();
}
La función millis()
Se
trata de una función de la librería de Arduino que devuelve el número de
milisegundos transcurridos desde el inicio del programa en Arduino hasta el
momento actual. Nos da un número entero y simplemente indica cuanto tiempo
lleva encendida la placa, a modo de reloj.
