Sunteți pe pagina 1din 17

Tutorial - Cruce de semforos LED

Objetivo: Montar un cruce de semforos con un tiempo de espera de 6 segundos


antes del cambio. La secuencia har una espera de 4 segundos en verde, 2
segundos parpadeando, luego Amarillo y luego Rojo (6 segundos de nuevo). El
botn lo programaremos para que reinicie el contador cambiando de semforo
(similar a cuando pulsamos el botn para cruzar en uno de estos).
Componentes a usar en este tutorial:
2 x Diodo LED Red
2 x Diodo LED Yellow
2 x Diodo LED Green
6 x Resistencia 220 ohmios
1 x Resistencia 10 Kohmios
1 x Arduino UNO
Cables
1 x Pulsador

En la imagen superior tenemos el diagrama del montaje. Podemos identificar los


LEDs, las resistencias y el botn pulsador.
Vamos a pasar a comentar las conexiones:
Para conectar nuestro Arduino UNO a la protoboard o BreadBoard sacaremos un
cable (cable rojo) del PIN 5V hasta nuestra fila positiva de la protoboard (+) y un
cable (cable azul) desde el PIN GND hasta nuestra fila (-) de la protoboard.
Para evitarnos problemas de conexin haremos ya el puente a mitad de la
protoboard. El cable azul de la imagen conecta la fila negativa para que todos los
pines estn unidos. Nota: esto no es obligado hacerlo pero suele ser til para
evitarnos problemas de montaje.
Ahora que ya tenemos la protoboard preparada para seguir, procederemos a
conectar nuestro botn pulsador. Este componente est dotado de 4 terminales o
"patas". Podemos conectarlo como en la imagen haciendo de puente entre las
bandas verticales de la protoboard. A la pata de la izquierda le conectaremos
la resistencia de 10 Kohmios y la resistencia ir conectada a la fila negativa
(GND) de la protoboard mediante un cable.
De la pata de la derecha del pulsador saldr un cable que conectara ste a la fila
positiva de la protoboard (5V).
Seguidamente procederemos a colocar los LEDs en la protoboard. Usando el polo
negativo del LED en la zona vertical de la protoboard y el positivo en la fila
negativa de la protoboard (GND) como indica la imagen. Del polo negativo del LED
deber ir conectado la resistencia de 220 ohmios como muestra la imagen. Es
recomendable que su disposicin tambin haga de puente entre las columnas
verticales de la protoboard.
Una vez tenemos montados y conectados los componentes, tan slo nos
faltarconectar los LEDs y el botn a nuestro Arduino UNO. Estas conexiones
las haremos de la siguiente manera:
Los LEDs los conectaremos desde la salida de la resistencia hacia el controlador.
(ver imagen)
- LED Verde (derecha): PIN 2 del Arduino.
- LED Amarillo: PIN 3 (PWM)
- LED Rojo: PIN 4
- LED Verde: PIN 5
- LED Amarillo: PIN 6
- LED Rojo: PIN 7
Por ltimo nos faltar conectar el botn a nuestro controlador. La pata superior
izquierda la conectaremos al PIN 8 del Arduino UNO. Cable negro de la imagen.

Ahora vayamos al programa:


/*
Programa para un par de semaforos que cambian de uno
a otro, y la implementacion de un boton para terminar
el tiempo de la luz verde y pasar al otro.
*/
// Declaramos la variable para el pin del boton
const int button = 8;
void setup() {
// Con un ciclo activamos los pines del 2 al 7 como salidas
for (int pin = 2; pin <= 7; pin++) {
pinMode(pin, OUTPUT);
}
// El pin del boton lo ponemos como entrada
pinMode(button, INPUT);
}
// Funcion para el primer semaforo y sus cambios de estado
void semaphoreOne() {
digitalWrite(2, HIGH);
int count = 0;
while (count < 30) {
// El ciclo esta en espera mientras el boton no es presionado
if (digitalRead(button) == true) {
break;
}
count++;

delay(200);
}
// Programamos el cambio entre semaforos. Cuando el LED tiene la posicion LOW estara
apagado, mientras que si esta en posicion HIGH estada encendido.
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
delay(2500);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
digitalWrite(7, LOW);
// Mandamos a llamar al otro semaforo
semaphoreTwo();
}
// Funcion para el segundo semaforo y sus cambios de estado
void semaphoreTwo() {
digitalWrite(5, HIGH);
int count = 0;
while (count < 30) {
if (digitalRead(button) == true) {
break;
}
count++;
delay(200);
}
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);

delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
delay(2500);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(4, LOW);
// Mandamos a llamar al otro semaforo
semaphoreOne();
}
// Iniciamos nuestro semaforo
void loop() {
// Cambiamos el estado de todos los leds para
// que esten apagados todos al inicio
for (int pin = 2; pin <= 7; pin++) {
digitalWrite(pin, LOW);
}
// Prendemos el verde de un semaforo y el
// rojo del otro semaforo
digitalWrite(2, HIGH);
digitalWrite(7, HIGH);
// Iniciamos el primer semaforo
semaphoreOne();
}

/*Fuente: http://ramon-gzz.blogspot.mx/2012/04/semaforo-con-arduino-uno.html

Secuencias de Luces

En ste tutorial reproducimos diferentes secuencias de luces. Para cambiar a la siguiente secuencia
presionamos el pulsador.
El programa utiliza estructuras switch anidadas, la de ms afuera sirve para rotar entre las
secuencias y las de adentro para rotar entre los estados de cada secuencia. Antes de eso evaluamos
si se ha presionado el pulsador y le dejamos de hacer caso dehabilitndolo por un rato. sto es
porque de lo contrario las secuencias rotaran unas miles de veces entre que presionamos y
soltamos el pulsador. En ste caso no podemos poner un simple delay para esperar a soltarlo
porque las secuencias tienen diferentes tiempos y se basan en que todo el programa se va a repetir
constantemente. Finalmente el cambio de estado dentro de la secuencia se evala al final del
programa.

Hardware Requerido

Arduino Uno
Protoboard
5 LEDs
5 resistencias de 220
Resistencia de 10K
Pulsador

Circuito

Esquemtico

Cdigo:
/*
Secuencias de Luces
Con este programa rotamos diferentes secuencias de luces al presionar
un pulsador.
*/
// Le damos nombre a los pines del arduino para poder entender mejor
// su funcion en el programa:
int led1 = 3;
int led2 = 5;
int led3 = 6;
int led4 = 9;
int led5 = 10;
int pinPulsador = A0; // Pin donde leemos el valor del potenciometro
// Variables
int estado_pulsador = 0; // Almacena el valor del potenciometro
int secuencias = 5; // Cantidad de secuencias programadas
int espera_pulsador = 500; // Tiempo en milisegundos que se espera antes
// de hacer una nueva lectura al pulsador
int conteo_pulsador = 0; // Contador que se compara con espera pusador
int intensidad = 0; // Intensidad de iluminacion
boolean habilitar_pulsador = false; // Indica si el pulsador se debe leer

boolean aumentando_intensidad = true; // Indica si la intensidad esta


aumentando
int tiempo = 100; // Tiempo base en milisegundos para cada iteracion
int secuencia = 1; // Secuencia actual en la que nos encontramos
int estado_secuencia = 1; // Estado de la secuencia actual en el que nos
encontramos
int estados = 1; // Estados por secuencia

void setup() {
// Inicializamos los pines de los leds como salidas
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
// Asignamos los valores iniciales a los leds (apagados)
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
}
void loop() {
// Leemos el estado del pulsador y lo alamacenamos
estado_pulsador = digitalRead(pinPulsador);
// Si el pulsador esta habilitado y lo presionamos, cambiamos de secuencia
if (habilitar_pulsador && estado_pulsador == HIGH) {
// Rotamos la secuencia.
if (secuencia == secuencias) {
secuencia = 1;
} else {
secuencia = secuencia + 1;
}
estado_secuencia = 1;
habilitar_pulsador = false;
}
// Si el pulsador esta deshabilitado, evaluaremos el conteo de espera antes
de volver
// a habilitarlo.
if (habilitar_pulsador == false) {
// Si el conteo llega a espera_pulsador o se deja de presionar el
pulsador, lo habilitamos
if (conteo_pulsador >= espera_pulsador || estado_pulsador == LOW) {
habilitar_pulsador = true;
conteo_pulsador = 0;
} else {
conteo_pulsador = conteo_pulsador + tiempo;
}
}
// Evaluamos la secuencia actual
switch(secuencia) {
case 1:
// Secuencia 1: alterna encendido de LEDs
tiempo = 100;
estados = 4;
switch(estado_secuencia) {
case 1:

digitalWrite(led1,
digitalWrite(led2,
digitalWrite(led3,
digitalWrite(led4,
digitalWrite(led5,
break;
case 3:
digitalWrite(led1,
digitalWrite(led2,
digitalWrite(led3,
digitalWrite(led4,
digitalWrite(led5,
break;

LOW);
HIGH);
LOW);
HIGH);
LOW);

HIGH);
LOW);
HIGH);
LOW);
HIGH);

}
break;
case 2:
// Secuencia 2: mantiene todos los LEDs encendidos
tiempo = 100;
estados = 1;
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
digitalWrite(led3, HIGH);
digitalWrite(led4, HIGH);
digitalWrite(led5, HIGH);
break;
case 3:
// Secuencia 3: enciende y apaga todos los LEDs
tiempo = 100;
estados = 2;
switch(estado_secuencia) {
case 1:
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
digitalWrite(led3, HIGH);
digitalWrite(led4, HIGH);
digitalWrite(led5, HIGH);
break;
case 9:
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
break;
}
estados = 17;
break;
case 4:
// Secuencia 4: enciende y apaga todos los LEDs con atenuacion
estados = 15;
switch (estado_secuencia) {
case 1:
// Bajamos el tiempo a 5ms porque la atenuacion requiere
// que se incremente la intensidad de a pocos.
tiempo = 5;
if (aumentando_intensidad) {
intensidad = intensidad + 1;
if (intensidad >= 255) {
intensidad = 255;

aumentando_intensidad = false;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
} else {
intensidad = intensidad - 1;
if (intensidad <= 0) {
intensidad = 0;
aumentando_intensidad = true;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
}
analogWrite(led1, intensidad);
analogWrite(led2, intensidad);
analogWrite(led3, intensidad);
analogWrite(led4, intensidad);
analogWrite(led5, intensidad);
break;
case 2:
// Regresamos el tiempo a 100ms porque ya no necesitamos
//
tiempo = 100;
break;
}
break;
case 5:
// Secuencia 5: alterna encendido de LEDs con atenuacion
estados = 15;
switch (estado_secuencia) {
case 1:
// Bajamos el tiempo a 5ms porque la atenuacion requiere
// que se incremente la intensidad de a pocos
tiempo = 5;
if (aumentando_intensidad) {
intensidad = intensidad + 1;
if (intensidad >= 255) {
intensidad = 255;
aumentando_intensidad = false;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
} else {
intensidad = intensidad - 1;
if (intensidad <= 0) {
intensidad = 0;
aumentando_intensidad = true;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
}
analogWrite(led1, intensidad);
analogWrite(led2, 255-intensidad);
analogWrite(led3, intensidad);
analogWrite(led4, 255-intensidad);
analogWrite(led5, intensidad);
break;
case 2:
tiempo = 100;

break;
}
break;
}
// Evaluamos si llegamos al estado final
if ( estado_secuencia == estados ) {
estado_secuencia = 1;
} else {
estado_secuencia = estado_secuencia + 1;
}
// Esperamos "tiempo" milisegundos
delay(tiempo);
}

Hace un tiempo compre una placa de Arduino pero por falta de tiempo, haba hecho algunos
ejemplos pero quera al menos documentar como funciona de una manera sencilla (para
dummies), ademas que acabando de cursar una materia de la Universidad llamada
Microprocesadores en la cual se aprendi bastante pero tambin miraba que todo lo
que hacamos en las prcticas se me facilitara la vida si usara mi placa de Arduino (adems
que aunque los pics son baratos tocaba comprar quemador de pics) y bueno de ahi surgo
este pequeo ejemplo, espero que les guste y cualquier cosa no duden en preguntar o
colaborar en el aprendizaje de esta gran placa.
Materiales
1 Placa de arduino
1 Protoboard
8 Leds (cualquier color)
8 resistencias de 220
1 resistencia de 1 K
1 pulsador
Cable Utp
1 El programa consiste en que al presionar el pulsador los leds cambien de secuencia, las
secuencias son las siguientes (1) Leds Encendidos (0) Leds apagado:
a)
00000001
00000010
00000100
.
.
10000000
b)
00011000
00111100
01111110
11111111
c)
00000001
00000011
00000111
.
.
11111111

d)
00001111
11110000
.
.
2. Como sabemos los leds tiene un anodo (+) y un catodo (-), de un lado conectaremos todos
los Catodos a las resistencias de 220 y estas a GND y de los anodos conectaremos a los
pines del 2 al 9, las resistencias se colocan con el fin que no quemar los leds.
3. Conectamos el pulsador de la siguiente manera de un lado a 5V y del otro conectamos una
resistencia a tierra y tambien un cable al pin A0 que sera el que nos permita cambiar de
secuencia cada vez que lo presionemos, Se coloca la resistencia de 1 k porque haria un
puente entre GND y el pin A0 de esta manera la lectura de entrada sera siempre 0, al
presionar el pulsador lo que hace es hacer puente entre 5V y A0, de esta manera
conseguimos el valor de 1 con esto los valores de entrada unicamente seran 1 y 0.
Aqu muestro el montaje realizado en un software llamado Fritzing V 0.7.0 de licencia GNU
GPL v3 el cual lo pueden conseguir en http://www.fritzing.org

Montaje en Protoboard

Esquema Proyecto
4. Cargar el siguiente cdigo, esta explicado.

int saltar=0; // Variable que indica el numero de la secuencia a ejecutarse


void setup() {
pinMode(A0, INPUT); //indicamos el pin de entrada
for(int i=2;i<=9;i++){ //indicamos los pines de salida
pinMode(i, OUTPUT);
}
}
void loop() {
if (digitalRead(A0)==HIGH){ //Al presionar el pulsador
saltar++; // Cambia de secuencia
if (saltar>3){ //Solo hay 4 secuencias 0,1,2 y 3 al ser 3 . .
saltar=0; // Vuelve a secuencia 0
}
while (digitalRead(A0)==HIGH){} // Mientras se pulsa no haga nada mas
}
if(saltar==0){ //Si es 1 inicie funcion de secuencia1
secuencia1();
}
if(saltar==1){ //Si es 2 inicie funcion de secuencia2
secuencia2();
}

if(saltar==2){ //Si es 3 inicie funcion de secuencia3


secuencia3();
}
if(saltar==3){ //Si es 4 inicie funcion de secuencia4
secuencia4();
}
}
void secuencia1(){
for (int i=2; i<=9; i++){ //Pin 2 al 9
digitalWrite(i, HIGH); // Prenda pin actual
digitalWrite(i-1,LOW); // Apage el Anterior
delay(50); // retardo entre prender y apagar
}
for (int i=9; i>=2; i--){ //Al contrario de la
digitalWrite(i, LOW); // anterior secuencia va de 9 a 2
digitalWrite(i-1,HIGH);
delay(50);
}
}
void secuencia2(){
int k=11; // inicializo una variable auxiliar K
for(int i=6; i<=9;i++){ //leo de 6 a 9
digitalWrite(i, HIGH); // prendo pin actual
digitalWrite(k-i, HIGH); // prendo pin de la diferencia 11-6 = 5
delay(50); //retardo
}
for(int i=9; i>=2;i--){ // Al contrario de lo anterior
digitalWrite(i, LOW);
digitalWrite(k-i, LOW);
delay(50);
}
}
void secuencia3(){
for(int i=2; i<=9; i++){
digitalWrite(i,HIGH);
delay(50);
}
for(int i=9; i>=2;i--){
digitalWrite(i,LOW);
delay(50);

}
}
void secuencia4(){
int k=11;
for(int i=2; i<=5;i++){
digitalWrite(i,HIGH);
digitalWrite(k-i,LOW);
}
delay(150);
for(int i=2; i<=5;i++){
digitalWrite(i,LOW);
digitalWrite(k-i,HIGH);
}
delay(150);
}
Ahi los dejo con una imagenes y un video de lo que hace.