De programación por bloques a Arduino C++: tabla con MicroPython

La forma más rápida de pasar de la programación por bloques a Arduino C++ es tener a mano una tabla de una sola página que muestre en qué línea de código real se convierte cada bloque. La respuesta corta: los bloques no son un lenguaje nuevo, son la forma visual de las líneas de Arduino C++. El bloque «configurar pin 13 como SALIDA» es la línea pinMode(13, OUTPUT);, el bloque «esperar 1000 ms» es delay(1000); y el bloque «si … hacer» es una instrucción if. La tabla de abajo pone las etiquetas reales de los bloques de la app BlueGrays junto a su código Arduino C++ y su código MicroPython en la Raspberry Pi Pico.

Esta página no es una clase, es una hoja de consulta. Puedes imprimir la tabla, dejarla junto a tu mesa y comprobar qué línea corresponde a qué bloque mientras miras un proyecto. Después de la tabla encontrarás los errores más comunes al hacer el cambio, un método de cuatro pasos para dejar atrás los bloques y el mismo programa escrito en bloques, C++ y MicroPython. El ejemplo compila en el Arduino IDE y funciona en la Pico con Thonny.

Antes de leer la tabla: cuatro diferencias entre los tres

Bloques, C++ y MicroPython expresan la misma idea, pero las reglas de escritura cambian. Estas cuatro diferencias son donde más vas a tropezar. La primera es la estructura: un programa de Arduino C++ tiene dos partes llamadas setup() y loop(), que en bloques aparecen como «configuración (una vez)» y «repetir siempre». MicroPython no tiene un setup aparte; el archivo se ejecuta una vez de arriba abajo y la parte que se repite va dentro de un bucle while True:. La segunda son los tipos: en C++ cada variable lleva su tipo escrito (int, float, bool), en bloques es la opción «declarar entero (int)» y en Python no se escribe ningún tipo.

La tercera diferencia son los rangos numéricos. En el Arduino Uno una lectura analógica va de 0 a 1023 y el PWM de 0 a 255; en el ESP32 la lectura analógica llega a 0–4095; en la Pico, MicroPython da tanto las lecturas como el ciclo de trabajo PWM en el rango 0–65535. Por eso no puedes copiar un umbral de una placa a otra tal cual. La cuarta diferencia es la unidad de tiempo: delay() pide milisegundos y time.sleep() pide segundos. Medio segundo es delay(500) en C++ y time.sleep(0.5) en MicroPython. Si recuerdas estas cuatro reglas, la mayoría de las filas de la tabla encajan solas.

• Los números de la tabla son ejemplos: donde el bloque dice 13, tu proyecto puede usar 7, y el número de la línea de código cambia con él.
• Los pines de la columna MicroPython son números GP de la Pico (GP14, GP15, GP26). No tienen por qué coincidir con los pines del Uno; consulta el esquema.
• Las filas con «Sin bloque en Pico» indican que ese bloque no se usa en los proyectos de Pico; aun así se da el código MicroPython que hace lo mismo.
• El ESP32 también se programa en Arduino C++; la columna C++ le sirve igual, solo cambian el rango analógico y algunos números de pin.

Tabla de bloques, Arduino C++ y MicroPython

La tabla está dividida en 12 grupos: estructura del programa, pines, tiempo, condición, bucle, variables, matemáticas, puerto serie, analógico y PWM, sonido, servo y sensor. El texto de la columna Bloque es la etiqueta que aparece en los bloques de la app; «…» y «?» marcan el hueco donde encaja otro bloque. Cuando una fila tiene más de un bloque, van separados por un punto.

Algunas filas parecen equivalencias directas, pero piden atención. En «contar con i desde 0 hasta 5» el 5 está incluido y el bucle da 6 vueltas; por eso en C++ se escribe <= en lugar de <, y Python necesita range(0, 6), porque range deja fuera el número final. El bloque de división también tiene trampa: al dividir dos enteros, C++ descarta los decimales y 7 / 2 da 3, mientras que Python da 3.5. Para una división entera como la de C++, en Python se usa //. La función map() que hay detrás del bloque «mapear x» no viene incluida en MicroPython; en el ejemplo de abajo una función arduino_map() de dos líneas hace el mismo cálculo.

¿Cómo se convierten en código los bloques anidados?

Conocer los bloques sueltos no basta; la verdadera habilidad es convertir bloques anidados en una sola línea. Para eso distingue dos formas. Los bloques apilados uno bajo otro, con una muesca en el borde, son instrucciones y cada uno se convierte en una línea de código. Los bloques ovalados o en punta que encajan en el hueco de otro bloque son valores; en el código van dentro de paréntesis, a la derecha de un signo igual o dentro de una condición. Las filas de abajo salen del proyecto gratuito Ajuste de frecuencia con zumbador: cuatro pulsadores encienden y apagan el tono y suben o bajan su frecuencia, que se mantiene entre 50 y 5000 Hz.

Crea un hábito al leer esta tabla: traduce primero el bloque más interior y luego avanza hacia fuera. En «establecer frequency a (limitar frequency entre 50 y 5000)», lo más interior es constrain(frequency, 50, 5000), y el bloque establecer de fuera lo convierte en frequency = …. Un bloque de valor no puede ser una línea por sí solo; si lo dejas con un punto y coma, puede que el compilador no proteste, pero el resultado no se guarda en ninguna parte.

Errores comunes al pasar de bloques a código

El editor de bloques no te deja cometer la mayoría de estos errores; la forma de las piezas impide que encajen donde no deben. En el código esa protección desaparece, así que casi todo el mundo se encuentra los errores de abajo en las primeras semanas. Los mensajes de error llegan en inglés, pero los patrones son pocos y, tras verlos un par de veces, los reconocerás.

Dejar atrás los bloques: método en 4 pasos

Intentar el cambio de golpe cansa. Los cuatro pasos de abajo van de leer a escribir en etapas pequeñas. Con uno o dos proyectos por paso basta; estás listo para el siguiente cuando puedes hacer el actual sin mirar la tabla.

1. Lee en paralelo. Abre a la vez los bloques y el código de un proyecto y empareja con el dedo cada bloque con su línea de código. En este paso ten la tabla siempre al lado. Meta: poder relacionar cada línea de código con un bloque.
2. Oculta los bloques y adivina. Mira primero los bloques, luego desactiva la vista de bloques y escribe en papel el C++ de esos bloques sin mirar el código. Después compáralo con el código real. Prueba también al revés: lee el código y adivina los bloques.
3. Cambia un valor en el código. Pasa el código a tu ordenador y cambia un solo número: sube la espera de 100 a 500 o el umbral de 400 a 600. Súbelo y mira la diferencia con tus propios ojos. Si sale un error de compilación, vuelve a la tabla de errores de arriba.
4. Escribe una línea nueva. Añade una línea que no esté en los bloques: un Serial.println() que muestre el valor en el Monitor Serie, un segundo LED o un if que funcione con un pulsador. Ya no traduces bloques, escribes código directamente.

Cada paso tiene su lección en la serie. Para el primero, la tabla de bloque a línea de encender un LED con bloques es un buen comienzo. Para trabajar con condiciones y bucles en los pasos dos y tres, consulta el bloque si y bucles y variables. Si vas a pasar a MicroPython con la Pico, de los bloques a MicroPython explica también cómo instalar Thonny. Si quieres repartir el cambio en varias semanas de clase, el plan de robótica de 8 semanas te da un orden listo para usar.

Abrir bloques y código en paralelo en la app BlueGrays

Esta tabla te servirá sobre todo al ir y venir entre los bloques y el código de un proyecto real. La app BlueGrays tiene vista de bloques en más de 100 proyectos; en más de 30 proyectos gratuitos los bloques también están abiertos, y en los proyectos Premium los bloques se desbloquean con Premium. Los bloques son para leer: en la app no se editan bloques ni se suben a la placa. Lo que va a la placa es siempre el código real; lo tomas con Copiar, o con Copiar enlace para abrirlo en el ordenador, y lo pegas en el Arduino IDE o, para la Pico, en Thonny.

• Ver en bloques: activa este interruptor junto al código fuente en la página de un proyecto y el mismo programa aparece como imagen de bloques en el idioma de la app. Toca la imagen para verla a pantalla completa; activarlo y desactivarlo es justo la práctica de los pasos uno y dos.
• Entiende los bloques: con la vista de bloques activa, la pestaña «Entender el código» pasa a llamarse así. El programa se divide en pasos, cada uno con su parte y una explicación. La tarea «Pruébalo tú» del final es un ejercicio listo para el paso cuatro.
• Guía de código: cada una de las 36 tarjetas de la sección Aprende (18 de Arduino C++ y 18 de MicroPython) muestra su ejemplo de tres formas con las pestañas Bloques, Arduino y MicroPython. Si quieres ver una fila de la tabla con más detalle, abre la tarjeta correspondiente.
• Proyectos con bloques: esta opción dentro de Filtrar en Descubrir > Proyectos muestra solo los proyectos con vista de bloques y te facilita elegir uno para el cambio.

Explicamos cómo funciona la guía de código en el artículo sobre la guía de código, y las secciones «Entender el código» y «Pruébalo tú» en la guía de Entender el código. Para cada comando explicado uno a uno, la lista de comandos de Arduino combina bien con esta tabla.

Un programa en tres formas: luz nocturna que se atenúa con la luz

Para ver la tabla en acción, montemos un programa pequeño. Un LDR mide la luz; mientras la habitación está iluminada el LED sigue apagado, y a medida que oscurece el LED se enciende poco a poco. El programa usa bloques de variable, lectura analógica, condición, mapeo, PWM, puerto serie y espera, así que más de la mitad de la tabla aparece en un solo ejemplo. La idea se basa en el proyecto gratuito Luz nocturna con LDR; allí el LED solo se enciende o se apaga, aquí el PWM lo atenúa. Para conectar el LDR también puedes mirar el esquema del proyecto Medir la intensidad de luz con LDR.

Primero la versión en bloques. Con las etiquetas de la app, el programa está formado por estos bloques; cada punto corresponde a una o varias líneas del código C++ que sigue:

1. variables globales (al principio): declarar entero (int) lightValue = 0 y declarar entero (int) brightness = 0
2. configuración (una vez): iniciar serie a 9600 baudios y después configurar pin 9 como SALIDA
3. repetir siempre: establecer lightValue a (leer analógico A0)
4. si (lightValue < 400) hacer: establecer brightness a (mapear lightValue : 0 – 400 → 255 – 0); sino: establecer brightness a 0
5. escribir PWM brightness en pin 9
6. imprimir en serie «Light: » continuar, imprimir en serie lightValue continuar, imprimir en serie « PWM: » continuar, imprimir en serie brightness salto de línea
7. esperar 200 ms

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

Si comparas los dos programas línea a línea, aparecen todas las diferencias de la tabla. El setup() de C++ pasa a ser las líneas antes de while True en Python, y Serial.begin() desaparece. analogRead(A0) se convierte en ADC(26).read_u16() y el rango pasa de 0–1023 a 0–65535, por eso el umbral es 25600 en lugar de 400. En vez de analogWrite(9, …) primero se crea un objeto PWM y el brillo se fija con duty_u16() entre 0 y 65535. Como map() no viene incluido, se escribe una función arduino_map(); la división entera // que lleva dentro equivale a la división entera de C++. Un solo print() sustituye a cuatro Serial.print(), y delay(200) se convierte en time.sleep(0.2).

Pasar de la programación por bloques a Arduino C++ consiste menos en memorizar algo nuevo y más en reconocer la forma escrita de bloques que ya conoces. Ten esta tabla a mano, en cada proyecto lee primero en paralelo y luego oculta los bloques y escríbelo tú. Si quieres ver estas filas en proyectos reales, abre en la app BlueGrays un proyecto con vista de bloques y cambia entre las dos formas del mismo programa con Ver en bloques.