Programación por bloques Arduino: encender un LED paso a paso

En la programación por bloques con Arduino, el primer programa casi siempre es el mismo: hacer parpadear un LED. En este artículo lo hacemos de principio a fin. Conectamos un LED al pin 9 con una resistencia de 220 Ω, leemos uno a uno los bloques del proyecto Parpadeo de LED de BlueGrays y vemos, lado a lado, en qué línea del código C++ que se carga en la placa se convierte cada bloque. También probarás a cambiar un solo número, el 100 del bloque "esperar 100 ms", para controlar la velocidad del parpadeo.

No nos quedamos en un solo LED. Vamos a ampliar la misma lógica paso a paso hasta programas que encienden dos LED por turnos, funcionan como un semáforo y destellan como las luces de la policía. Después verás la misma idea en el ESP32 y en la Raspberry Pi Pico con MicroPython. Al final tienes una tabla con los errores que casi todo principiante comete alguna vez. Todos los proyectos de este artículo son gratuitos en BlueGrays, con bloques y código, y puedes ver todos los proyectos con bloques por plataforma en la página de programación por bloques.

¿Qué necesitas?

El circuito: conectar el LED al pin 9

Un LED tiene dos patas y la polaridad importa. La pata larga es el ánodo (+) y la corta el cátodo (-); en el lado del cátodo el encapsulado de plástico tiene un borde plano. La corriente solo circula del ánodo al cátodo, así que si lo pones al revés no pasa nada. Conecta el pin 9 del Arduino a un extremo de la resistencia de 220 Ω y el otro extremo a la pata larga del LED. La pata corta va a GND. La resistencia limita la corriente: a los 5 V les restas los unos 2 V del LED rojo, quedan 3 V en la resistencia, y 3 V / 220 Ω son unos 14 mA. Es una corriente cómoda para el LED y segura para el pin del Arduino. Puedes comprobar el valor para el color de tu LED con la calculadora de resistencia para LED. Cómo funciona un LED lo cuentas en qué es un LED, y cómo se conectan por dentro las filas de la protoboard en qué es una protoboard.

Tu primer programa con bloques: Parpadeo de LED

Con el circuito listo, veamos el programa. Abre el proyecto Parpadeo de LED en BlueGrays y activa Ver en bloques en la sección de código; verás los bloques de abajo. Son siete bloques en total, repartidos en dos grandes grupos: arriba configuración (una vez) y debajo repetir siempre. Los bloques aparecen en el idioma de la app: en español dicen "escribir ALTO en pin" y en inglés "write HIGH to pin".

Los bloques de configuración (una vez) se ejecutan una sola vez, al encender la placa o al pulsar reset. Aquí hay un único bloque: "configurar pin 9 como SALIDA". Los pines digitales del Arduino pueden ser entradas o salidas. Como vamos a controlar un LED, le decimos a la placa "por este pin voy a sacar corriente". El grupo repetir siempre empieza cuando termina la configuración y se ejecuta de arriba abajo una y otra vez mientras la placa esté encendida. Sus cuatro bloques encienden el LED, esperan 100 milisegundos, lo apagan y esperan otros 100 milisegundos. Tras el último bloque el programa vuelve arriba y el LED se enciende de nuevo. Lo que llamamos parpadeo no es más que estos cuatro pasos repitiéndose cinco veces por segundo.

Bloque → línea C++: ¿en qué se convierte cada bloque?

1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8  digitalWrite(9,HIGH);  // LED'i yak / turn the LED on
9  delay(100);            // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10  digitalWrite(9,LOW);   // LED'i söndür / turn the LED off
11  delay(100);            // 100 ms bekle / wait 100 ms
12}
13

Si pones la tabla junto al código, ves todo lo que los bloques resuelven por ti. La forma de los grupos configuración y repetir siempre corresponde a las llaves de las funciones void setup() y void loop(): el grupo en el que está un bloque decide dentro de qué llaves se escribe su línea. Con bloques no tienes que pensar en el punto y coma al final de cada instrucción, en mayúsculas y minúsculas (pinMode, digitalWrite) ni en los paréntesis. Pero cuando empiezas a modificar el código tú mismo en el Arduino IDE, sí importan; basta un punto y coma olvidado para tener un error de compilación. Esa es la gran ventaja de los bloques: primero asientas la lógica del programa y luego aprendes cómo se escribe esa misma lógica en código.

¿Qué pasa si cambias "esperar 100 ms"?

El tiempo de espera va en milisegundos (ms), y 1000 ms son un segundo. Los dos bloques de espera del proyecto están en 100 ms, así que el LED pasa 0,1 segundos encendido y 0,1 segundos apagado. Un ciclo completo dura 200 ms, es decir, el LED parpadea cinco veces por segundo. Si subes el número en los dos bloques el LED va más lento, y si lo bajas, más rápido. A partir de cierto punto el ojo ya no distingue los parpadeos y el LED parece encendido todo el tiempo. La tabla muestra lo que verás al cambiar las dos esperas:

Ampliar el programa: dos LED, semáforo y luces de policía

Si ya sabes hacer parpadear un LED, para controlar varios no necesitas nada nuevo: repites los mismos tres bloques con otros pines. En el proyecto Dos LED parpadeando alternadamente se configuran dos pines como salida: 8 y 9. Dentro de repetir siempre van "escribir ALTO en pin 8" y "escribir BAJO en pin 9", y luego "esperar 200 ms". Después se escribe al revés y se esperan otros 200 ms. El truco está en que los dos bloques de escritura se ejecutan seguidos, sin espera entre ellos, así que los LED parecen cambiar en el mismo instante. El bloque de espera decide cuánto dura cada estado.

El proyecto Semáforo lleva la misma idea a tres LED: rojo en D2, amarillo en D3 y verde en D4. El grupo repetir siempre tiene cuatro fases y todas siguen el mismo patrón: un bloque escribir ALTO o BAJO para cada uno de los tres LED y después un bloque de espera. Los bloques de escritura deciden qué LED queda encendido y el de espera, durante cuánto tiempo. Más bloques no lo hacen más difícil, solo más largo. Una versión con pulsador peatonal, más cercana a un cruce real, está en el artículo semáforo con Arduino.

1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3  pinMode(2,OUTPUT);    // Kırmızı / Red
4  pinMode(3,OUTPUT);    // Sarı / Yellow
5  pinMode(4,OUTPUT);    // Yeşil / Green
6}
7
8void loop() {
9  // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10  digitalWrite(2,HIGH);
11  digitalWrite(3,LOW);
12  digitalWrite(4,LOW);
13  delay(2000);
14  // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15  digitalWrite(2,LOW);
16  digitalWrite(3,HIGH);
17  digitalWrite(4,LOW);
18  delay(300);
19  // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20  digitalWrite(2,LOW);
21  digitalWrite(3,LOW);
22  digitalWrite(4,HIGH);
23  delay(2000);
24  // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25  digitalWrite(2,LOW);
26  digitalWrite(3,HIGH);
27  digitalWrite(4,LOW);
28  delay(300);
29}
30

En el proyecto Luces de policía LED aparecen dos tipos de bloque nuevos. El primero es el grupo variables globales (al principio) con el bloque "declarar entero (int) delayTime = 60". Es la línea int delayTime = 60; del código y le pone nombre al tiempo de destello. Como los bloques de espera usan delayTime en lugar de un número, para cambiar la velocidad solo modificas el 60, no cuatro bloques distintos. El segundo es el bloque verde "repetir 3 veces": ejecuta tres veces los cuatro bloques que contiene y en C++ se convierte en el bucle for(int i=0;i<3;i++).

Hagamos cuentas: en cada destello el LED rojo está 60 ms encendido y 60 ms apagado, así que un destello dura 120 ms. Tres destellos son 360 ms, y lo mismo para el LED azul. Un ciclo completo dura unos 0,7 segundos. Con delayTime en 30 destella el doble de rápido y con 120, más despacio. Las variables y los bucles son el tema de la parte 4 de la serie; los vemos en detalle en "repetir siempre", bloques de contar y arrays. El proyecto Luz secuencial LED, que hace correr la luz por una fila de LED, es el siguiente paso del mismo camino.

La misma idea en ESP32 y Raspberry Pi Pico

En el ESP32 los bloques son casi idénticos a los de Arduino, porque el ESP32 también se programa en C++ con el Arduino IDE. En el proyecto LED parpadeante con ESP32 el LED está en el GPIO 5 y los bloques de espera son de 500 ms. Las líneas de código también son iguales: pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. Las únicas diferencias son el número de pin, que los pines del ESP32 dan 3,3 V y que en el Arduino IDE hay que elegir una placa ESP32. Todo lo que aprendes con el Uno pasa directamente al ESP32.

En los proyectos de Raspberry Pi Pico los bloques se convierten en código MicroPython y los nombres de los bloques cambian un poco. En el proyecto LED externo con la Pico el LED está en GP14. El bloque "pin led : GP LED_PIN, SALIDA" corresponde a led = Pin(LED_PIN, Pin.OUT), "encender (on) el pin led" a led.on(), "esperar 0.5 segundos" a time.sleep(0.5) y repetir siempre al bucle while True:. Ojo: en MicroPython la espera va en segundos, no en milisegundos; el delay(500) de Arduino aquí es time.sleep(0.5). Si quieres probar sin ningún cable, el proyecto LED integrado de la Pico enciende el LED de la propia placa en GP25; en la Pico W al LED integrado se accede con el nombre "LED" en lugar de GP25.

1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14                    # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT)     # pini çıkış yap / set the pin as output
8
9while True:                     # sürekli tekrarla / loop forever
10    led.on()                    # LED'i yak / turn the LED on
11    time.sleep(0.5)             # 0,5 saniye bekle / wait 0.5 s
12    led.off()                   # LED'i söndür / turn the LED off
13    time.sleep(0.5)
14

Errores frecuentes y cómo solucionarlos

Paso a paso en la app: de los bloques a la placa

1. En BlueGrays, abre el proyecto Parpadeo de LED, que lleva la insignia de bloques en la lista de proyectos. Con el filtro también puedes mostrar solo los proyectos con bloques.
2. Siguiendo el esquema, coloca en la protoboard el LED, la resistencia de 220 Ω y dos cables.
3. En la sección de código, activa Ver en bloques. En lugar del código verás los bloques; al tocar la imagen se abre a pantalla completa.
4. Pasa a la pestaña Entiende los bloques. El programa se explica paso a paso y en cada paso solo ves sus bloques y lo que hacen.
5. Desactiva el interruptor para volver al código real, cópialo y pégalo en el Arduino IDE. Los bloques no se cargan directamente en la placa; lo que va a la placa es siempre este código.
6. En el Arduino IDE elige Arduino Uno como placa y el puerto correcto, y pulsa Subir. Si aún no tienes el IDE, el artículo instalar Arduino IDE te guía paso a paso.
7. Cuando el LED parpadee, cambia las dos líneas delay(100) por delay(1000), vuelve a cargar y comprueba la diferencia con tus propios ojos.

En este artículo el LED siempre parpadeó al mismo ritmo; el programa no escuchaba nada del exterior. El siguiente paso es que la placa tome decisiones: la parte 3 de la serie, el pulsador y el bloque "si", muestra un programa que enciende el LED al pulsar un botón y cómo ese bloque se convierte en if/else en C++.

En la app BlueGrays puedes ver Parpadeo de LED, Dos LED parpadeando alternadamente, Semáforo, Luces de policía LED y los proyectos de LED para ESP32 y Pico con su esquema y su código, pasar a la versión en bloques del mismo programa con Ver en bloques y leer qué hace cada paso con Entiende los bloques.