Bucles y variables en programación por bloques con Arduino

Los bucles y las variables en la programación por bloques son las dos piezas que convierten un programa de "haz esto una vez" en "hazlo todo el rato y con cabeza". Un bucle ejecuta los mismos bloques una y otra vez, y una variable recuerda un número mientras tanto. En los bloques de BlueGrays aparecen como "repetir siempre", "contar con i", "variables globales (al principio)" y "establecer … a"; en el código de Arduino que se carga en la placa, sus equivalentes son loop(), el bucle for, una variable int y una línea de asignación.

En esta parte leeremos los bloques de cuatro proyectos gratuitos junto a su código C++ real: Luz secuencial LED, que enciende seis LED uno tras otro; Luz secuencial LED con velocidad regulable, que toma la velocidad de un potenciómetro; Efecto coche fantástico con LED, que lleva la luz de un extremo al otro y la trae de vuelta; y su versión con potenciómetro, Efecto coche fantástico con velocidad regulable. Los cuatro usan el mismo circuito: seis LED en los pines D2–D7 y un potenciómetro en A0. Al final escribirás tu propio ejemplo de contador y verás uno por uno los tres errores más habituales de quien empieza: contar uno de más o de menos, salirse del arreglo y las esperas largas que dejan ciegos a los botones.

El bloque "repetir siempre" y loop(): ¿por qué la placa nunca se detiene?

Un programa del ordenador se cierra cuando termina su trabajo; un programa de Arduino no. La placa no tiene sistema operativo y el procesador no tiene otra cosa que hacer. Por eso todos los proyectos con bloques tienen el mismo esqueleto: lo que va dentro de "configuración (una vez)" se ejecuta una sola vez al dar corriente a la placa o pulsar el botón de reset, y lo que va dentro de "repetir siempre" se repite de arriba abajo sin parar. En C++ son las funciones setup() y loop(). Cuando termina la última línea de loop(), la placa vuelve enseguida a la primera; un loop() corto y sin esperas puede ejecutarse decenas de miles de veces por segundo. La única forma de pararla es quitarle la corriente o cargar otro programa. Esta repetición infinita no es un fallo, es el diseño: leer un botón, vigilar un sensor o encender un LED se hace de nuevo en cada vuelta, y así la placa responde siempre a lo que cambia a su alrededor.

Variables en la programación por bloques: variables globales y el bloque declarar

Una variable es una cajita en la que guardas un número y a la que llamas por su nombre. En los bloques, las variables se crean dentro del bloque morado "variables globales (al principio)". El bloque "declarar entero (int) potValue = 0" que va dentro se convierte en la línea int potValue del código: int es el tipo, potValue el nombre y 0 el valor inicial. Lo de "al principio" importa: estas líneas van arriba del todo en el archivo, fuera de setup() y de loop(). Una variable global declarada así se ve desde cualquier parte del programa y no pierde su valor cada vez que loop() vuelve a empezar. En el Arduino Uno un int ocupa 2 bytes y guarda números enteros de -32768 a 32767, más que suficiente para el rango 0–1023 de analogRead() y para los números de pin. Quizá notes que los bloques de Luz secuencial LED con velocidad regulable dicen potValue = 0 y su código solo int potValue;. El resultado es el mismo: en C++ una variable global sin valor inicial empieza en cero.

El bloque que cambia una variable más tarde es "establecer … a". El bloque "establecer potValue a leer analógico A0" se traduce en potValue = analogRead(A0); en el código. El signo = aquí no es la igualdad de matemáticas; significa "calcula el valor de la derecha y guárdalo en la caja de la izquierda". La comparación que pregunta si dos valores son iguales se escribe con == en C++, como vimos con el bloque si en la parte anterior de la serie. Cuando el bloque establecer se ejecuta, el valor antiguo se borra y se escribe el nuevo. Todos los bloques que leen la variable usan desde ese momento el nuevo valor: "esperar potValue ms" espera tantos milisegundos como valga potValue en ese instante.

El bucle de conteo: el bloque "contar con i" y el bucle for de Arduino

Para repetir algo un número fijo de veces se usa el bloque verde "contar con i desde 0 hasta 5 de a 1". Crea un contador llamado i, le da el valor 0, ejecuta los bloques de dentro, suma 1 a i, los vuelve a ejecutar y sigue así hasta que i pasa de 5. Su equivalente en Arduino es la línea for (int i = 0; i < 6; i++). Dentro del paréntesis hay tres partes separadas por punto y coma: el inicio (int i = 0), la condición para seguir (i < 6) y el paso tras cada vuelta (i++, es decir, sumar uno a i). Lo más importante: el valor final del bloque está incluido. "Desde 0 hasta 5" significa 0, 1, 2, 3, 4 y 5, así que el bucle da 6 vueltas, no 5, y cada uno de los seis LED recibe la suya. Por eso el código pone i < 6, que equivale a i <= 5. El patrón "empieza en cero y sigue mientras sea menor que el número de elementos" es muy común en Arduino porque el 6 te dice directamente cuántos LED hay.

El bloque arreglo: "arreglo 2 3 4 5 6 7" y ledPins[i]

En lugar de declarar seis variables para seis LED, puedes guardarlos todos en una sola lista. Cuando el bloque morado "arreglo 2 3 4 5 6 7" se encaja en "declarar entero (int) ledPins = …", se convierte en la línea int ledPins[] = {2, 3, 4, 5, 6, 7}; del código. Los corchetes indican que es un arreglo y las llaves contienen sus valores. A cada elemento se llega por su posición, el índice, y en C++ el índice empieza en 0: el primer elemento es ledPins[0] y el último ledPins[5]. En los bloques esto lo hace "elemento i de ledPins", que pasa a ser ledPins[i]. Como el bucle de conteo también empieza en 0, encajan a la perfección: en cada vuelta i da el siguiente índice y ledPins[i] el número de pin guardado ahí. Otra ventaja: si quieres cambiar el orden de los LED, solo cambias los números de la lista, sin tocar el bucle. Tienes más detalles en arreglos en Arduino.

Luz secuencial LED: bloques y C++ línea por línea

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Piensa en el programa como una línea de tiempo. Al arrancar, el bucle de la configuración pone los seis pines como salida uno a uno, del 0 al 5, y eso no se repite nunca más. Después empieza repetir siempre: el bucle de conteo de dentro enciende el LED de D2, espera 150 ms, lo apaga y hace lo mismo con D3, D4, D5, D6 y D7. Una vuelta dura 6 × 150 = 900 ms. Cuando se apaga el último LED, loop() termina, la placa vuelve enseguida al principio y la luz arranca otra vez en D2; como no hay pausa entre vueltas, parece que la luz fluye sin parar. Para cambiar la velocidad basta con cambiar un número, el 150: con 50 la luz va tres veces más rápida, con 500 pasea tranquilamente. Hacer que esa velocidad fija se pueda ajustar con una perilla nos lleva al siguiente proyecto.

Luz secuencial LED con velocidad regulable: el valor del potenciómetro es la espera

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

La única diferencia con la luz secuencial LED son dos bloques nuevos. A las variables globales se añade "declarar entero (int) potValue = 0" y el bucle de conteo empieza con "establecer potValue a leer analógico A0". analogRead(A0) convierte la tensión de la pata central del potenciómetro en un número de 0 a 1023; ese número va directo a "esperar potValue ms", es decir, a la línea delay(potValue). Si giras la perilla hacia un extremo, cada LED queda encendido cerca de un segundo (1023 ms) y una vuelta dura unos 6 segundos; hacia el otro extremo la espera baja a 0 y los LED cambian tan rápido que parecen brillar débilmente todos a la vez. Leer el potenciómetro dentro del bucle, antes de cada LED, es una decisión pensada: el siguiente LED ya usa la nueva velocidad en cuanto giras, sin esperar a que termine la vuelta. Cómo funciona un potenciómetro lo explicamos en qué es un potenciómetro.

Coche fantástico: dos bucles que cuentan hacia delante y hacia atrás

En el efecto coche fantástico la luz viaja de un extremo al otro y vuelve. Los bloques de Efecto coche fantástico con LED tienen dos bucles de conteo, uno debajo del otro, dentro de repetir siempre. El primero es el conocido "contar con i desde 0 hasta 5 de a 1" y lleva la luz de D2 a D7. El segundo es "contar con i desde 4 hasta 1 de a 1": como el inicio es mayor que el final, el bloque cuenta hacia atrás y i vale 4, 3, 2, 1. En el código es la línea for(int i = 4; i > 0; i--); i-- resta uno a i. ¿Por qué de 4 a 1 y no de 5 a 0? Porque ledPins[5] (D7) ya se enciende al final de la ida y ledPins[0] (D2) al principio de la siguiente. Saltarse los extremos al volver evita que los LED de las puntas se enciendan dos veces seguidas, y el rebote se ve fluido. Una ida y vuelta son 6 + 4 = 10 pasos de 100 ms, 1 segundo en total. Efecto coche fantástico con velocidad regulable usa los mismos dos bucles; solo añade "establecer potValue a leer analógico A0" al principio de ambos y usa "esperar potValue ms" en lugar de 100 ms. Para más patrones, echa un vistazo a coche fantástico y luz secuencial con Arduino.

Tu propio ejemplo de contador: contador de vueltas y puerto serie

Ahora vamos a escribir un pequeño ejemplo que lo une todo: cada vez que la luz secuencial termina una vuelta sube un contador, y la placa envía al ordenador tanto los valores de i como el número de vueltas. Con los bloques de las imágenes se montaría así: bajo el arreglo ledPins, en las variables globales, se añade "declarar entero (int) rounds = 0". En la configuración entra el bloque "iniciar serie a 9600 baudios". Dentro del bucle de conteo, antes de encender el LED, unos bloques "imprimir en serie" muestran el texto "i = ", luego i y luego el texto " pin = " con la opción "continuar", y al final "elemento i de ledPins" con la opción "salto de línea". Tras el bucle de conteo, todavía dentro de repetir siempre, un bloque "establecer rounds a …" recibe la suma rounds + 1 y el número de vueltas se imprime con "imprimir en serie … salto de línea".

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

Después de cargarlo, abre el monitor serie del Arduino IDE y ponlo a 9600 baudios. En cada vuelta verás seis líneas, de "i = 0 pin = 2" a "i = 5 pin = 7", y después una línea "Tur / Round" que cuenta 1, 2, 3. Esta salida es la prueba más clara de que el valor final del bloque contar está incluido: "desde 0 hasta 5" produce exactamente seis valores. Fíjate también en que rounds está declarada en las variables globales; no se reinicia cada vez que empieza loop(), sino que conserva su valor de una vuelta a otra. Una vuelta dura 6 × 300 = 1,8 segundos, así que el límite de int, 32767, se alcanza en unas 16 horas; si necesitas contar más tiempo, usa unsigned long. Tienes más sobre el monitor serie en monitor serie de Arduino.

Circuito: 6 LED, resistencias de 220 Ω y un potenciómetro

Una resistencia de 220 Ω deja pasar unos (5 − 2) / 220 ≈ 14 mA por un LED rojo alimentado a 5 V, un valor seguro para el LED y para el pin de Arduino. Si usas LED de otro color, comprueba la resistencia con la calculadora de resistencia para LED. Reúne todos los cátodos en la línea GND de la protoboard y conéctala al pin GND del Arduino. Si inviertes las patas exteriores del potenciómetro no se rompe nada; solo cambia el sentido de giro. La luz secuencial LED y el coche fantástico no usan el potenciómetro, pero dejarlo conectado no molesta, así que puedes probar los cuatro proyectos seguidos en el mismo circuito.

Errores comunes con bucles y variables

Explorar los bloques de bucles y variables en la app BlueGrays

Los cuatro proyectos de este artículo y los siguientes son totalmente gratuitos en la app BlueGrays, con bloques y código. En la sección de código de un proyecto, activa el interruptor Ver en bloques y el código se sustituye por los bloques del mismo programa; si tocas la imagen se abre a pantalla completa y puedes ampliar con comodidad los bucles largos. La pestaña Entiende los bloques recorre el programa paso a paso y en cada paso muestra solo sus bloques y lo que hacen. Otros proyectos gratuitos que vale la pena ver en bloques: Luces de policía LED, que funciona con una variable delayTime y dos bucles de conteo; Semáforo, que pasa por cuatro estados dentro de repetir siempre; Medir la intensidad de luz con LDR, que guarda su lectura en una variable y la imprime por el puerto serie; y Encender y apagar un LED con un botón, que recuerda el estado del LED en una variable. Cada ejemplo de Arduino de la Guía de código también está en bloques, y las Preguntas del día te ayudan a afianzar lo aprendido con 5 preguntas diarias de A1 a C2. La lista completa de proyectos con bloques está en la página de programación por bloques. Los bloques no se cargan directamente en la placa; a la placa siempre va el código real del proyecto, así que copias en el Arduino IDE el programa que entendiste con los bloques y lo cargas.

Ahora que conoces los bucles y las variables, el siguiente paso es sacar esos números del mundo real: en la parte 5 de la serie contamos cómo leer sensores con bloques, el puerto serie y el paso a MicroPython en la Pico. Mientras tanto, en la app BlueGrays puedes ver la luz secuencial LED, el coche fantástico y sus versiones con velocidad regulable con esquema y código, pasar a los bloques con Ver en bloques y a la explicación paso a paso con Entiende los bloques, y seguir tú mismo a qué línea de código corresponde cada bucle de conteo.