lunes, 21 de marzo de 2016

Semáforo para vehículos y paso de peatones con Arduino UNO

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. 

1 comentario: