Práctica 20. Semáforo con contador de cuenta regresiva

El Por En Arduino

20.1  Objetivo General:

Cambiar la luz de un semáforo de verde a rojo para permitir el paso peatonal. Se utiliza una subrutina para contar el tiempo que el semáforo debe estar en luz roja.
Mostrar un conteo regresivo utilizando un visualizador de 7 segmentos

20.2  Materiales y Métodos:

  1. Un visualizador LED de 7 segmentos.
  2. Dos resistencias de 220Ω.
  3. Un cable USB impresora.
  4. Un computador.
  5. Cables para el montaje del circuito.
  6. Tres LEDs (Colores: Amarillo, Verde y Rojo).
  7. Una tarjeta Arduino Uno-R3 o Arduino Mega 2560.
  8. Tarjeta Protoboard.
  9. Tres Resistencias Eléctrica de 220 ohm.
  10. Un Botón Pulsador.

20.3 Montaje de la práctica:

Antes de comenzar el montaje del circuito, se proyecta su montaje en el programa Fritzing. Recuerde que para instalar los LED se debe conocer cuall es el cátodo y ánodo de los LED (práctica 1). Se coloca el ánodo del LED verde en el pin 13, LED amarillo en el pin 12 y LED rojo en el pin 8. El cátodo de cada LED va a tierra (ground). Se va a usar el pin 5V para alimentar el botón pulsador tal como se muestra en la figura 2:


Figura 1. Montaje del circuito en el programa Fritzing

Se observa en la Figura 2 que se usa una placa Arduino Uno y un protoboard para instalar los LEDs, resistencia, botón y cables. La línea que esta de color rojo emite los 5V al botón pulsador. El computador es capaz de proveerle Arduino 5V. Los 5V  van hacia al botón y luego al cerrarse el circuito le deja pasar al pin 7. Para proteger el circuito y evitar que al pin 7 no le llegue más de 5V, se coloca una resistencia eléctrica.

Luego que proyectar el circuito en el programa Fritzing se procede desarrollarlo en el protoboard. Luego, se comienza con a programar en el IDE de Arduino.

Para el contador de siete segmentos se procede a proyectar su montaje en el programa Fritzing. Recuerde que para instalar los LED se debe conocer cual es el cátodo y ánodo de los LED (práctica 1). Se coloca el ánodo del LED verde en el pin 13, LED amarillo en el pin 12 y LED rojo en el pin 8. El cátodo de cada LED va a tierra (ground). Se va a usar el pin 5V para alimentar el botón pulsador tal como se muestra en la figura 2:


Figura 2 – Montaje del circuito para un visualizador de 7 LEDs. (práctica 19)

Note que en la práctica se emplea un visualizador que consiste en un circuito constituido por 7 LEDs. El número a visualizar se consigue encendiendo y apagando cada LEDs. Por ejemplo, el número 8 se muestra cuando los 7 LEDs están encendidos.

El circuito de la figura 2 corresponde con el circuito donde el cátodo es común. Un GND (-) común para los 4 LEDs superiores y un GND (-) común para los 3 LEDs inferiores. Aunque la señal enviada por la tarjeta arduino es baja y puede conectarse directamente a los LEDs, es recomendable incluir una resistencia eléctrica tal y como se muestra en la figura

Para encender los segmentos, lo que se debe hacer es enviar la señal digital desde la tarjeta arduino al pin ánodo del LED. La tabla 1 resume la secuencia de LEDs que debe encenderse, para el visualizador de cátodo común, para mostrar uno de los números de 0 a 9. La tabla indica la variable que hay que activar la cual toma el nombre de la usada en el código. Por ejemplo, led2 es la variable constante y entera usada para activar el LED horizontal superior.

Tabla 1 Secuencia de LEDs para visualizar número

Númeroled2led3led4led5led6led7led8
01111110
10110000
21101101
31111001
40110011
51011011
61011111
71110000
81111111
91111011

20.4 Codificación de la práctica

20.4.1 IDE de Arduino para la práctica:

– Se selecciona la tarjeta Arduino que se está utilizando.

– Se selecciona el Puerto Serial. Bajo que puerto USB se va a conectar el Arduino con el computador.

– Se empieza a realizar el código:

  • Inicialmente debemos darle un nombre de qué consiste el codigo, esto se hace a través del símbolo //, se puede colocar el título de la práctica o del programa en sí. También se puede utilizar como comentarios dentro del programa.
  • Se declaran las variables. Los pines 8, 12 y 13 se usaran para alimentar los LEDs. Por lo que se declaran 3 parámetros que serán constantes del tipo entero led_verde, led_rojo y led_amarillo.   También se declara que el botón estará en el pin 7. Se usará una variable del tipo entero val igual a para tener guardado el estado del botón.
  • En el lazo void setup () se inicializan las variables. La primera acción del código será ejecutar la subrutina pedestriaBoton(). Note que las subrutinas son pedazos de código aparte que se usan para desarrollar una parte del código. Las subrutinas permiten reducir el tamaño del código ya que si una misma acción se repite constantemente esta puede codificarse mediante subrutinas. Para mas información sobre subrutinas ver la definición en wikipedia.
  • La subrutina pedestriaBoton() tiene la función de verificar si el botón fue pulsado el código debe esperar 500 por cada lazo indicado en el comando for. Por ejemplo,  i=i=1;i<21; indica que el lazo se ejecuta 20 veces, si el boton está apagado seria 20 x 500 milisegundos = 10 segundos. Esto indica que si se oprime el botón, en 10 segundos saldrá de la subrutina. 
  • Si el botón se pulsa, en 10 segundos el código sigue y se encuentra con que debe apagar el LED verde, luego encender el amarillo por 1 segundo delay(1000).  Finalmente enciende el LED rojo para que el peaton pueda cruzar.
  • En el código, el LED rojo se enciende por 5 segundos y luego se apaga. Una vez que se apaga el LED rojo, nuevamente se vuelve a encender el LED verde para que los vehículos continuen su transito por la via.
  • Si el botón no se activa if (state==0) , la luz roja esperará 20 x 1000 milisegundos = 20 segundos en cambiar al verde. Se puede jugar con el delay de 1000 milisegundos para prolongar por mas tiempo la luz roja y que esta se active solo en el caso de que el peatón oprima el botón.
  • Al terminar el desarrollo del programa se debe compilar para verificar si existen errores dentro del codificado. Luego si no existen errores se debe cargar el código en la tarjeta Arduino para que lo ejecute.

NOTA: Para quel IDE de Arduino pueda entender los comandos es necesario que al final de cada instrucción se coloque punto y coma (;).

20.4.2 Codificación del contador regresivo

Primero vamos a crear la subrutina funcNum(int x) que dado el número requerido (x entero) enciende la  secuencia de LEDs indicada en la tabla 1.

  • Las subrutinas se codifican en una estructura void seguida del nombre que se le quiera asignar. por ejemplo void funcNum(int x). Dentro del paréntesis se pueden colocar las variables que entran a la función. En este caso la variable de entrada es el número que se quiere visualizar.
  • En esta práctica vamos a utilizar la estructura de programación switch.. En este caso hay 10 posibilidades, desde 0 a 9. Por ejemplo, si la entrada x= 9 el código va al case 9 en el cual mediante digitalWrite(led, HIGH) se van encendiendo la secuencia requerida para visualizar el número 9..

A continuación se presenta el algoritmo y como queda plasmado en el IDE de Arduino de los procedimientos anteriormente explicados:

Codificación de semáforo con contador

//Semáforo
//declarando parametros
int led_verde= 13;
int led_amarillo= 12;
int led_rojo= 11;
const int BOTON=7; // pin de entrada botón
int state = 0; // estado del boton
void setup() {
// se indica que cada pin es de salidad OUTPUT.
pinMode(led_verde, OUTPUT);
pinMode(led_amarillo, OUTPUT);
pinMode(led_rojo, OUTPUT);
// se apagan todos los LEDs
digitalWrite(led_verde,LOW);
digitalWrite(led_amarillo,LOW);
digitalWrite(led_rojo,LOW);
// se indica que el pin 7 es de entrada INPUT
pinMode(BOTON,INPUT);
// pines 2-5 y 8-10 encienden leds del visualizador de segmentos
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
}
// lazo a ejecutar continuamente una vez cargado el código en el arduino
void loop(){
digitalWrite(led_verde,HIGH); // encender LED verde
//pedestriaBoton();  // se llama a una subrutina 
delay(5000);
digitalWrite(led_verde,LOW)); // apagar LED verde
digitalWrite(led_amarillo,HIGH)); // encender LED amarillo
delay(1000); // mantener por 1 segundos
digitalWrite(led_amarillo,LOW); // apagar LED verde
digitalWrite(led_rojo,HIGH); // encender LED rojo

,for(int i=9;i>-1; i--){
	funcNum(i);
	delay(1000);
} 
digitalWrite(led_rojo,LOW);
}



void funcNum(int x){
  switch (x){
    case 0://when count value is zero show”0” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(10, HIGH);
      digitalWrite(2, LOW);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
    break;
   case 1:// when count value is 1 show”1” on disp
      digitalWrite(8,HIGH);
      digitalWrite(9, LOW);
      digitalWrite(10, LOW);
      digitalWrite(2, LOW);
      digitalWrite(3, LOW);
      digitalWrite(4, LOW);
      digitalWrite(5, HIGH);
    break;
    case 2:// when count value is 2 show”2” on disp
      digitalWrite(8, LOW);
      digitalWrite(9, HIGH);
      digitalWrite(10, HIGH);
      digitalWrite(2, HIGH);
      digitalWrite(3, LOW);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
    break;
    case 3:// when count value is 3 show”3” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(10, LOW);
      digitalWrite(2, HIGH);
      digitalWrite(3, LOW);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
    break;
    case 4:// when count value is 4 show”4” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, LOW);
      digitalWrite(10, LOW);
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, LOW);
     digitalWrite(5, HIGH);
    break;
    case 5:// when count value is 5 show”5” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH;
      digitalWrite(10, LOW);
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, LOW);
    break;
    case 6:// when count value is 5 show”5” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(10, HIGH);
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, LOW);
    break;
  	case 7:// when count value is 5 show”5” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, LOW);
      digitalWrite(10, LOW);
      digitalWrite(2, LOW);
      digitalWrite(3, LOW);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
    break;
      case 8:// when count value is 8 show”8” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(10, HIGH);
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
    break;
     break;
      case 9:// when count value is 8 show”8” on disp
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(10, LOW);
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
    break;
 break;
   
}
}

Implementación del algoritmo en TinkerCAD:

https://www.tinkercad.com/things/kEmDMn6jujV

20.5 Conclusión:

En esta práctica hemos trabajado de forma integral las prácticas 18 y 19 respectivamente. Hemos utilizado las subrutinas para indicarle al circuito el momento que debe hacer el cambio de la luz verde a roja. El circuito junto con el código desarrollado permitió simular el comportamiento de un semáforo cuando es accionado por un botón peatonal. Hemos utilizado el lazo for para visualizar el conteo regresivo de 9 a 0. Se puede visualizar de manera más dinámica la realización de la práctica a través del enlace de TinkerCAD suministrado arriba.

Si nuestro contenido te fue de utilidad, por favor considera dar tu apoyo a lo que hacemos: