Uno de los proyectos típicos cuando nos iniciamos con Arduino, es hacer un semáforo. En este artículo vamos a darle una vuelta de tuerca, vamos a crear un semáforo inteligente. Simularemos esa inteligencia con dos pulsadores, múltiples LEDs y mucha imaginación.
El objetivo de este tutorial es mostrarte cómo utilizar múltiples LEDs con Arduino y también como integrarlo con dos pulsadores. Estos últimos se pueden sustituir por algún sensor de presencia ya sea ultrasonidos (ya hemos visto un ejemplo en el sensor de aparcamiento) o con infrarrojos.
Vamos a simular un cruce de semáforos en una calle. Los semáforos van a tener una característica especial, van a funcionar solos. Con los múltiples LEDs crearemos las luces de los semáforos. Los pulsadores simularán sensores de presencia.
El funcionamiento es muy simple. Cuando un coche llega a un semáforo en rojo se detiene. Esta situación la simularemos activando el pulsador asociado (como si fuera un sensor de presencia). Tras un tiempo de espera, se pondrá en rojo el otro semáforo y el semáforo donde está esperando el coche, se pondrá en verde.
Indice de contenidos
- 1 LEDs con Arduino, todo lo que necesitas saber
- 2 Pulsadores con Arduino, controla el flujo de la corriente
- 3 Circuito semáforo inteligente con múltiples LEDs y pulsadores
- 4 Programando el semáforo inteligente con múltiples LEDs y pulsadores
- 5 Conclusión de los múltiples LEDs y pulsadores con el semáforo inteligente
LEDs con Arduino, todo lo que necesitas saber
Lo primero que debemos saber antes de utilizar múltiples LEDs, es que se trata de un diodo. Este tipo de componentes son muy particulares ya que solo dejan pasar la electricidad en un sentido.
Pero ¿cuál es ese sentido? Es muy sencillo y con la práctica, te acostumbrarás a utilizarlos. Los LEDs tienen una patilla más larga que otra, esa patilla se conoce como ánodo (el polo positivo). Es por donde tiene que entrar la corriente. La patilla más pequeña se conoce como cátodo (polo negativo) y es por donde saldrá la corriente de electrones.
Teniendo claro esto ya podemos conectar múltiples LEDs a nuestro circuito. Ahora solo nos hace falta saber quá resistencia poner. Para ello debemos hacer uso de la Ley de Ohm. Esta Ley es la base fundamental sobre la que debemos construir nuestros circuitos.
¿Por qué debemos conectar una resistencia? Siempre tenemos que mirar la hoja de características técnicas de los componentes. Para un LED típico de 500 mm, el voltaje de operación está entre 1,8 V y 2,2 V. En caso contrario podemos dañar el LED o como mínimo, disminuir la vida útil del componente.
Ley de Ohm
Esta Ley relaciona las tres magnitudes básicas de un circuito voltaje, corriente y resistencia. Debes conocer y memorizar las fórmulas que nos ayudan a calcular una magnitud en relación a las otras. Existe un círculo que te ayuda fácilmente a recordar esta relación. Tapando la magnitud que quieres calcular te dice cómo hacerlo en base a las otras dos magnitudes.
Donde:
- V es voltaje
- I es intensidad
- R es resistencia
| Calcular Voltaje | Calcular Intensidad | Calcular Resistencia |
 |  |  |
 |  |  |
Con esta fórmula ya podemos calcular cualquier magnitud. En principio, necesitamos conocer dos de las magnitudes para calcular la tercera. En el ejemplo del semáforo inteligente con múltiples LEDs y pulsadores, tendremos que calcularlo una sola vez. Veamos cómo hacerlo.
Obteniendo la información para conectar un LED con Arduino
Vamos a recopilar la información que tenemos. Imagínate este circuito.
En un circuito en serie como el del ejemplo, da lo mismo colocar la resistencia antes que después. Si aplicas la Ley de Ohm se obtiene el mismo valor. En ningún momento esta Ley nos dice la posición de los componentes. Esto también es aplicable a múltiples LEDs.
Según aumentemos el valor de la resistencia, el Arduino LED suministrará menos luminosidad.
Es un circuito muy simple, un LED y yba resistencia en paralelo. Pero, ¿cómo calculamos el valor de la resistencia? Sólo tenemos que aplicar la Ley de Ohm. Conocemos el voltaje, por los pines digitales se suministran 5 V. La intensidad la podemos sacar de la hoja de características técnicas del propio Arduino. Si nos dirigimos a su web oficial podemos ver el detalle que te muestro en la siguiente imagen.
La intensidad es de 20 mA (miliamperios) que son 0,02 A (Amperios). El voltaje que tiene que caer en la resistencia es 5 V menos lo que consume el LED, entre 1,8 V y 2,2 V. Esto nos da que la resistencia debe consumir como mínimo 3,2 V.
Ya tenemos todo, solo hace falta sustituir los valores y calcular el valor de la resistencia.
Ojo, que este es el mínimo. Por debajo de ese valor de resistencia podemos dañar el LED, ya que aumentaría el voltaje y nos saldríamos del rango de operación. En mi caso voy a utilizar resistencias de 220Ω por comodidad. Esto me da como resultado que en la resistencia se consumirán 4,4 V y quedarían 0,6 V para consumir en el LED. Estoy por debajo de lo recomendado pero no dañaré el LED.
Pulsadores con Arduino, controla el flujo de la corriente
Otro componente que vamos a utilizar y que debemos conocer son los pulsadores. Gracias a estos componentes podemos dejar pasar o no la corriente. Al utilizar un pulsador con Arduino tenemos que tener ciertas precauciones, sobre todo cuando la salida la conectamos a un pin digital, como es el caso. Lo primero es ver un esquema general de un pulsador.
El típico tiene cuatro patillas. Están conectadas entre ellas dos a dos y entre ellas forman el interruptor. Un pulsador no es más que un interruptor, deja pasar la corriente o no. Seguro que te suena todo esto, dos estados posibles :). Exacto, a través de un pin digital podemos saber si se ha pulsado o no un pulsador.
Resistencia pull down, evita indeterminaciones en los pulsadores
Seguramente hayas oído hablar de las resistencias pull down y pull up. Se trata de dos configuraciones que nos permiten tener un estado bajo (0 Voltios) o estado alto (5 Voltios) cuando un cable está al aíre.
Esto es lo que sucede con los pulsadores, mientras que no pulsemos, tenemos el pin al aire y se produce una indeterminación. Las dos configuraciones posibles son las siguientes.
El valor típico de la resistencia debe ser el mayor posible. Los 10kΩ es el aconsejable para utilizar un pulsador con Arduino.
Circuito semáforo inteligente con múltiples LEDs y pulsadores
Pues ya tenemos todo claro de cómo utilizar múltiples LED, pulsadores y Arduino para crear el semáforo inteligente. Ahora te detallaré los componentes que vamos a necesitar.
Componentes necesarios
Asegúrate que tienes los siguientes componentes para montar el circuito.
- Arduino UNO (o equivalente)
- Protoboard donde conectamos los componentes
- 6 resistencias 220 Ω
- 2 resistencias 10 kΩ
- 3 LEDs verdes
- 3 LEDs amarillos
- 3 LEDs rojos
- 2 pulsadores
Múltiples LEDs y pulsadores, Montando el circuito del semáforo inteligente
En este circuito, al utilizar tantos componentes tenemos que llevar mucho cuidado con los cortocircuitos. Esto haría que el sistema no se comporte como esperamos. Ves conectando poco a poco y una vez conectado, prueba cada componente para asegurarte de que todo funciona correctamente.
Los múltiples LEDs van a formar los semáforos de un cruce. Los pulsadores simularán sensores de presencia. El circuito sería el siguiente.
Las resistencias conectadas a los múltiples LEDs son de 220 Ω y la de los pulsadores 10 kΩ.
Es una buena práctica utilizar cables de colores agrupados para los múltiples LEDs y para el pulsador. Eso te permitirá localizarlos más rápidamente.
Programando el semáforo inteligente con múltiples LEDs y pulsadores
Lo primero es comprender el problema. Vamos a simular un cruce de calles con múltiples LEDS, que harán de semáforos, y dos pulsadores, que harán de sensores de presencia. El objetivo es que cuando se sitúe un coche en un semáforo que está en rojo, permita que se ponga en verde y cierre el otro semáforo.
Para empezar tenemos que partir de unas condiciones iniciales, ¿qué semáforo comienza abierto y qué semáforo comienza cerrado? Empezaremos con el semáforo 1 abierto y el semáforo 2 cerrado. Para entendernos, en el esquema del circuito eléctrico, de izquierda a derecha será semáforo 1, semáforo 2, pulsador 1 (simula sensor de presencia del semáforo 1) y pulsador 2 (simula sensor de presencia del semáforo 2).
Una vez que un coche esté parado ante un semáforo en rojo (simulamos pulsando su pulsador), pasará un determinado tiempo y comenzará la secuencia para apagar el otro semáforo y abrir el suyo. Sencillo ¿no?. Pues vamos a ver el algoritmo.
- Establecer condiciones iniciales
- LED verde semáforo 1 encendido
- LED rojo semáforo 2 encendido
- Semáforo 1 activo
- Comprobar que semáforo está activo
- Semáforo 1 activo
- Comprobar pin pulsador 2
- Si pulsado
- Cambiar semáforo 1 a rojo
- Cambiar semáforo 2 a verde
- Si pulsado
- Comprobar pin pulsador 2
- Semáforo 2 activo
- Comprobar pin pulsador 1
- Si pulsado
- Cambiar semáforo 2 a rojo
- Cambiar semáforo 1 a verde
- Si pulsado
- Comprobar pin pulsador 1
- Semáforo 1 activo
Variables y constantes
Lo primero es declarar las constantes que identifiquen los múltiples LEDs y los pulsadores. Eso lo hacemos en la parte de arriba del sketch o programa.
|
1 2 3 4 5 6 7 8 9 |
// Pines utilizados #define LEDVERDE1 2 #define LEDAMARILLO1 3 #define LEDROJO1 4 #define LEDVERDE2 5 #define LEDAMARILLO2 6 #define LEDROJO2 7 #define PULSADOR1 8 #define PULSADOR2 9 |
Luego vamos a declarar tres variables. La primera será del tipo booleano, solo admite dos valores a True (verdadero) o False (falso). Esta variable nos permitirá saber que semáforo está activo. Cuando solo tenemos dos posibilidades, es una buena práctica utilizar este tipo de variables.
En nuestro caso ponemos el nombre activo1. Si es True indica que el semáforo 1 está activo y en verde y por lo tanto el semáforo 2 está no activo y en rojo. Si activo 1 es False, indicará que el semáforo 2 está activo y en verde y el semáforo 1 estará no activo y en rojo.
Las otras dos variables son los tiempos de espera. La primera es el tiempo que esperamos para cambiar de luces (de verde a amarillo y luego a rojo) y la segunda es un tiempo más largo. Sirve para esperar un tiempo prudencial antes de hacer el cambio de semáforos.
|
1 2 3 4 |
// Variables bool activo1 = true; // Indica si el semáforo 1 está activo, de lo contrario será el semáforo 2 int tiempoCambio = 1500; // Tiempo de espera entre transición de LEDs int tiempoEspera = 5000; // Tiempo de espera hasta comenzar transición |
Función setup
Ahora vamos a pasar a indicar las condiciones iniciales. Ya lo he comentado anteriormente. Comenzaremos con el semáforo 1 activo (verde) y el semáforo 2 no activo (rojo). Pero antes de hacer esto, iniciamos el monitor serie, ponemos los pines de los múltiples LEDs en modo salida (OUTPUT) y los pines de los pulsadores en modo entrada (INPUT).
Por último, apagamos los múltiples LEDs.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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 activo, semáforo 2 no activo digitalWrite(LEDVERDE1, HIGH); digitalWrite(LEDROJO2, HIGH); } |
Función loop
Esta función es la que se va a repetir indefinidamente. Aquí comprobaremos el estado de los pulsadores, encenderemos y apagaremos los múltiples LEDs según corresponda. He dividido el código en dos funciones, a parte de la función loop(). Si tenemos que encender el semáforo 1, llamamos a la función encenderSemaforo1(), y si tenemos que encender el semáforo 2, llamamos a la función encenderSemaforo2().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
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; } } } |
Es importante cambiar de semáforo activo. Eso se hace poniendo a True o False la variable activo1. También podríamos hacerlo poniendo activo1 = !activo1; Esto quiere decir que cogerá el valor contrario False si es True o True si es False.
Existen dos palabras reservadas dentro de la API de Arduino que indican el estado de un pin digital, LOW y HIGH. Estas constantes se definen igual que las constantes para indicar el número de un pin que hemos utilizado para un componente en la parte inicial de este código. LOW tiene asociado el valor 0 u HIGH tiene asociado el valor 1. Por eso podemos guardar el valor de una entrada digital en una variable del tipo int.
La función encenderSemaforo1() y encenderSemaforo2() se encargan de hacer la secuencia correspondiente para apagar y encender un semáforo. Primero esperamos el tiempo de espera definido por tiempoEspera. Luego apagamos el otro semáforo y por último encendemos el semáforo activo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
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); } |
Aunque es un tema algo más complejo, podemos utilizar interrupciones para realizar este ejercicio. El único inconveniente que veo son los tiempos de espera. Con las funciones callback de las interrupciones no podemos utilizar la función delay().
Código final
Como siempre, te dejo todo el código unido para que lo utilices en tus proyectos con Arduino. Intenta hacerlo tu sólo, ya que copiar y pegar no te ayuda a entender las cosas. Recuerda que hemos utilizado múltiples LEDs y pulsadores.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
// Pines utilizados #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 = 1500; // Tiempo de espera entre transición de LEDs int tiempoEspera = 5000; // 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); } |
Conclusión de los múltiples LEDs y pulsadores con el semáforo inteligente
Bueno pues otro ejercicio práctico para comenzar a cacharrear con Arduino y cualquier dispositivo del movimiento Maker. Es importante ir practicando con esto ejemplos antes de enfrentarnos a cualquier otro proyecto de mayor magnitud. La idea es que lo hagas tu sólo, sin fijarte en lo que yo hago salvo que te quedes atascado.
Hemos utilizado múltiples LEDs para simular los semáforos y pulsadores para simular los sensores de presencia. Prueba a cambiar estos componentes por otros.
Si te ha gustado comparte, y si tienes dudas deja un comentario, gracias :)
Gracias a Shutterstock por ceder los derechos de la imagen
