En este primer reto vamos a describir la práctica elemental con la que todos nos iniciamos en el mundo de Arduino: encender y apagar un LED (Light Emitting Diode).
Es la práctica habitual en un primer contacto con Arduino, y que nos servirá también para trabajar con nuestra primera entrada/salida digital (pin nº 13) y comprender cómo cargar un programa desde el interfaz de Arduino.
El OBJETIVO de nuestro montaje será conectar un LED y que parpadee de forma intermitente con una pausa de 1 segundo = 1000 ms (milisegundos, unidades con las que trabaja el IDE de Ardunio).
Necesitaremos los siguientes componentes:
- una placa Arduino.
- un led, siguiendo el siguiente enlace podrás saber más acerca de las características electrónicas de un led y su cálculos para montaje en serie. Resumiendo, un diodo, es un componente electrónico que solo permite pasar la corriente en una dirección y que si se monta a la inversa no emitirá luz alguna como se esquematiza gráficamente.
- una resistencia (ver más adelante cómo calcularla correctamente aplicando las Leyes de Ohmn).
- dos cables que harán de conectores.
- una placa de prototipado para realizar dicho montaje.
.
Con esta tabla podrás calcular fácilmente el valor de la resistencias o resistores fijos. También puedes usar este otro recurso.
.
El montaje a realizar sería el siguiente:
.
.
Una vez realizado el montaje, ya sólo nos queda probar el código fuente en nuestro IDE de Arduino para comprobar que nuestro montaje funciona perfectamente. Utilizaremos el programa “Blink” que ya viene incluido en la librería de ejemplos de Arduino y que podemos encontrar en el menú: Archivo>Ejemplos>Básics>Blink. Un consejo importante es que nunca modifiqueis directamente estos archivos de ejemplo porque se quedará grabado en la librería de vuestro programa. Lo recomendable siempre será crear una copia del original y trabajar con él.
Tal y como explico en ¿CÓMO FUNCIONA ARDUINO? tenemos dos partes bien diferencias en nuestro código.
Por una parte, dentro de la función setup() que la utilizamos para inicializar valores, mediante la instrucción pinMode(13, OUTPUT) estamos definiendo que vamos a utilizar la salida digital 13 y que la ponemos en estado OUTPUT, puesto que su función será la de recibir estados HIGH (encender) o LOW (apagar).
En la función loop(), que albergará todas las instrucciones que se van a repetir en nuestro programa hasta que decidamos parar de forma manual, nos encontramos con la instrucción digitalWrite(13,HIGH), mediante la cual estamos programando para que la salida digital 13 se encienda. Cuando usamos la misma instrucción con el valor LOW en el segundo parámetro, estamos programando que se apague el led.
Por último, entre ambas instrucciones situamos la instrucción delay(1000), que nos servirá para introducir una pausa de 1000ms (1 segundo) entre los estados de encendido y apagado de nuestro led.
Llegados a este punto ya podemos cargar nuestro programa en Arduino para comprobar si nuestro montaje físico en la placa es el correcto.
Por si aún sigues teniendo dudas sobre cómo realizar todo este proceso, no dudéis en contactarme, aquí, o podéis encontrar información ampliada del código fuente y la explicación del montaje en el siguiente enlace a la página oficial de Ardunio.
Hay que recordar que una señal es digital cuando solo puede tomar dos valores, el máximo asociado a 1, cierto u “on” y el mínimo asociado a cero, faso u “off”.
Elementos digitales son: pulsador, detector de presencia, LED, zumbador, servomotor…
PARA SABER y COMPRENDER
Es importante comprender qué resistores fijos debemos conectar a un led y por qué, así como entender las leyes de Ohmn y los cálculos necesarios tanto en circuitos en serie como en paralelo. Para todo ello os recomiendo encarecidamente que consultéis la siguiente web.
A continuación tenéis un ejemplo de código con el que encendemos y apagamos a la vez 4 leds conectados en paralelo, el tiempo de encendido es de 500 milisegundos y el de apagado 100 milisegundos:
int led1 = 5; int led2 = 6; int led3 = 7; int led4 = 8; void setup() { pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(led3, OUTPUT); pinMode(led4, OUTPUT); } void loop() { digitalWrite(led1, HIGH); digitalWrite(led2, HIGH); digitalWrite(led3, HIGH); digitalWrite(led4, HIGH); delay(500); digitalWrite(led1, LOW); digitalWrite(led2, LOW); digitalWrite(led3, LOW); digitalWrite(led4, LOW); delay(100); }
Ahora veamos una optimización del ejemplo anterior, esto es, conseguir lo mismo con menos instrucciones:
int i = 0; // Inicializamos la variable i como un entero int led1 = 5; int led2 = 6; int led3 = 7; int led4 = 8; void setup() { pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(led3, OUTPUT); pinMode(led4, OUTPUT); } void loop() { for (i = 5 ; i < 9 ; i++) { digitalWrite( i , HIGH); } delay (500); for (i = 5 ; i < 9 ; i++) { digitalWrite( i , LOW); } delay (100); }
EXTRA BALLS
Ahora que ya hemos realizado con éxito nuestro primer montaje, como paso final en esta sesión, os reto a realizar las siguientes variaciones:
- Aumentar frecuencia parpadeo (cambiar los valores del delay).
- Añadir un segundo o tercer led y que parpadeen alternativamente.
- Añadir la instrucción FOR (estructura de control), combinada con una variable i (una variable es un contenedor que puede tomar varios valores, en este caso se usaría int para declarar que es un número entero) para:
- Repetir el programa con tantos leds como quiera montar de manera eficiente sin tener que escribir el programa repitiendo lo mismo tantas veces como leds haya.
- Conseguir el efecto del COCHE FANTÁSTICO (esto es el efecto ida y vuelta de parpadeo de los leds).
-
Similar al anterior del coche fantástico pero que el efecto conseguido sea como una OLA de tal forma que las luces van avanzando quedándose encendidos los leds hasta alcanzar el mayor y luego descender apagándolos.
void loop() { int i = 0; // Inicializamos la variable i como un entero for (i = 6 ; i < 14 ; i++) { digitalWrite( i , HIGH); delay (500); digitalWrite( i , LOW); delay (500); } }
NOTAS: Ojo que las instrucciones que se aplican a bloques de contenido no llevan ; final, como es el caso de for, void loop(), void setup(). Los 3 parámetros dentro del intervalo de la instrucción for significan lo siguiente:
- i=6 es la VARIABLE ÍNDICE o valor inicial que toma la variable.
- i < 14 es la CONDICIÓN que debe cumplir para que el ciclo continúe dentro del bucle y se repita, en este caso mientras la i sea menor que 14, es decir, que se repetirá hasta la variable 13, ejecutando por última vez el conjunto de instrucciones dentro del bucle for para salir del mismo al alcanzar la cifra de 14, ya que 14 no es menor que 14.
- i++ es el ALGORITMO que define cómo cambia la variable en cada repetición, en este caso concreto como un incrementador, sumándole una unidad.
.
- Añadir y programar 5 leds en serie, calculando previamente el valor del resistor fijo que necesitaremos.
- El mismo paso anterior pero realizando el montaje en paralelo.
- Conseguir que un led se comporte como una salida analógica encendiéndose y apagándose suavemente y progresivamente, es decir, atenuándose. La modulación de ancho de pulso (PulseWidth Modulation, PWM) es una técnica para obtener un comportamiento similar al analógico de una salida digital apagándola y encendiéndola muy rápido y con una relación diferente entre el tiempo de encendido y apagado, de tal forma que al ojo humano parece que se atenúa. Hay que prestar especial atención en este reto a que el pin digital del led debe ser de lectura PWM. A continuación os pongo dos ejemplos de código para conseguir este efecto de atenuación, el segundo es más complejo:
int ledPin = 9; void setup() { pinMode(led, OUTPUT); } void loop() { for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) { // El led se desvanece de mínimo a máximo en incrementos de 5 puntos analogWrite(ledPin, fadeValue); // Ejecuto el valor (desde 0 a 255) delay(30); } for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) { // El led se desvanece de máximo a mínimo en incrementos de 5 puntos analogWrite(ledPin, fadeValue); delay(30); } }
AHORA UNO MÁS COMPLEJO USANDO EL OPERADOR BOOLEANO OR ||:
int led = 9; // Conectamos el led a un pin digital PWM int brightness = 0; // Los leds soportan valores desde 0 hasta 255, empezamos en 0 int fadeAmount = 5; // Cantidad de desvanecimiento void setup() { pinMode(led, OUTPUT); } void loop() { analogWrite(led, brightness); brightness = brightness + fadeAmount; // Cambiamos el brillo para el siguiente bucle if (brightness <= 0 || brightness >= 255) { // Este condicional sirve para cambiar de sentido de atenuamiento. fadeAmount = -fadeAmount; } delay(30); }
NUMERO DE BUCLE |
brightness |
fadeAmount |
INICIO |
0 |
5 |
1 |
0 + 5 = 5 |
5 |
2 |
5 + 5 = 10 |
5 |
3 |
10 + 5 = 15 |
5 |
… |
… |
… |
¿? |
245 + 5 = 250 |
5 |
¿? |
250 + 5 = 255 |
-5 |
¿? |
255 – 5 = 250 |
-5 |
¿? |
250 – 5 = 245 |
-5 |
… |
… |
… |
¿? |
5 – 5 = 0 |
5 |
¿? |
0 + 5 = 5 |
5 |
¿? |
5 + 5 = 10 |
5 |
Con la anterior tabla se puede entender el funcionamiento del operador booleano OR
.