mBlock Arduino: tutorial de instalación, modo en vivo y bloques

Programar Arduino con mBlock es una de las formas más fáciles de hacer que un Arduino Uno encienda un LED o lea un pulsador o un sensor sin escribir una sola línea de código. mBlock 5, desarrollado gratis por Makeblock, es un entorno de programación por bloques basado en Scratch 3.0: unes bloques de colores como un rompecabezas y mBlock los convierte en segundo plano en código Arduino C, lo compila y lo carga en tu placa. Si quieres, también puedes ejecutar los bloques en la placa al instante y hacer que interactúen con los personajes del escenario. Por eso es una de las herramientas más usadas en las clases de robótica y programación, en los proyectos de feria de ciencias y como primer paso con Arduino.

En esta guía verás paso a paso cómo instalar mBlock en tu ordenador o usarlo en el navegador, añadir y conectar un Arduino Uno como dispositivo, cargar el firmware del modo en vivo, la diferencia entre el modo en vivo y el modo carga, los bloques de LED, pulsador y sensores, en qué líneas de Arduino C se convierten los bloques, nueve actividades para usar en clase, el paso al Arduino IDE y las soluciones a los problemas de conexión más habituales.

¿Qué es mBlock y cómo funciona con Arduino?

mBlock es un entorno de programación construido sobre Scratch 3.0, que se desarrolló en el MIT. Su gran diferencia con Scratch es que, además de los personajes de la pantalla (objetos), puede programar hardware real. La interfaz tiene dos pestañas separadas: en la pestaña Sprites (objetos) programas los personajes del escenario y en la pestaña Devices (dispositivos) programas placas como Arduino, micro:bit o los robots de Makeblock. Al elegir un dispositivo, la paleta de bloques recibe categorías propias de esa placa; en el Arduino Uno son los bloques de pines y de puerto serie. En modo carga, tu secuencia de bloques se traduce a Arduino C, se compila a código máquina y se graba por USB en la memoria flash de la placa. Es decir, mBlock hace el mismo trabajo que el Arduino IDE con una interfaz de bloques, y como te muestra el código que genera, también facilita el paso al código de texto.

Instalar mBlock: versión de escritorio y versión web

1. En el navegador, entra en mblock.cc y descarga desde la página de descargas (Download) la versión de escritorio de mBlock 5 para tu sistema operativo. Al escribir este artículo, la versión actual es la V5.6; funciona en Windows 7 o posterior de 64 bits y en macOS 10.12 o posterior, con un instalador aparte para los Mac con chip Apple M.
2. En Windows, ejecuta el instalador y sigue el asistente. Si durante la instalación te propone instalar el controlador CH340, acepta: la mayoría de las placas Arduino clónicas usan este chip USB-serie y, sin el controlador, el puerto no aparece.
3. En macOS, si el instalador no se abre, haz clic derecho sobre el archivo y elige Abrir, o usa el botón Abrir igualmente en Privacidad y seguridad de los Ajustes del Sistema.
4. Abre mBlock y elige Español en el icono del globo del menú superior. A partir de ahí, los menús y los nombres de los bloques aparecen en español.
5. En los ordenadores del colegio donde no puedas instalar programas, abre ide.mblock.cc en el navegador; para conectar Arduino usa una versión actualizada de Chrome o Edge.

Durante mucho tiempo, la versión web se conectaba a la placa mediante un pequeño programa auxiliar llamado mLink. En las versiones recientes, el método por defecto es la conexión directa, que usa la función de puerto serie del navegador: al pulsar conectar, el navegador abre una ventana, eliges el puerto del Arduino y te conectas sin instalar nada más. Este método funciona con Uno, Nano, Nano (old) y Mega 2560; las placas que usan el USB de otra forma, como Leonardo, Micro y Yun, siguen necesitando mLink. Mientras mLink está en marcha, aparece un pequeño icono de panda en la barra de tareas. No tengas abiertas a la vez la versión de escritorio y la web, ni dos pestañas de mBlock: ambas intentan usar el mismo puerto y la conexión falla.

Añadir un dispositivo: conectar el Arduino Uno a mBlock

1. Conecta el Arduino al ordenador con un cable USB; el LED ON (alimentación) de la placa debe encenderse.
2. En mBlock, pasa a la pestaña Devices (dispositivos), bajo el escenario. Quita el dispositivo de Makeblock que viene por defecto (Codey Rocky o CyberPi, según la versión) con la cruz de su esquina.
3. Pulsa + Add (añadir), escribe "Arduino" en el buscador de la biblioteca de dispositivos, elige Arduino Uno y pulsa OK. Si haces clic en la estrella de la esquina superior izquierda de la placa, mBlock la tendrá lista la próxima vez que lo abras.
4. Pulsa Connect (conectar). En la pestaña USB de la ventana que se abre, elige el puerto que ha encontrado mBlock: en Windows verás un nombre como COM3 o COM4; en macOS, algo como /dev/cu.usbmodem… o, en placas con CH340, /dev/cu.wchusbserial…. Si el puerto no aparece, marca la casilla Show all connectable devices (mostrar todos los dispositivos conectables).
5. Vuelve a pulsar Connect. Si aparece el mensaje "Device connected" (dispositivo conectado), ya está; en la paleta aparecen los bloques de pines y de puerto serie propios de Arduino.

Elegir bien el dispositivo es media batalla ganada. Sea original o clónica, elige Arduino Uno para un Uno y Arduino Mega2560 para un Mega. La mayoría de los Arduino Nano clónicos baratos llevan el bootloader antiguo; en estas placas la carga falla con Arduino Nano, mientras que la opción Arduino Nano (old) funciona. Las placas nuevas con otro procesador, como el Arduino Uno R4, no se pueden programar con el dispositivo Uno de mBlock; para ellas usa directamente el Arduino IDE. Si aún no sabes qué placa comprar, lee ¿Qué Arduino comprar?, y para el patillaje del Nano consulta la guía de pines del Arduino Nano.

Diferencia entre el modo en vivo y el modo carga

mBlock ofrece dos modos para programar dispositivos, y cambias entre ellos con el interruptor de la pestaña Devices. En el modo en vivo (Live), el programa se ejecuta en realidad en el ordenador: mBlock lee los bloques uno a uno y envía al Arduino por USB órdenes como "enciende el pin 13" o "lee A0 y mándame el resultado". Para ello, el Arduino necesita un firmware especial que entienda esas órdenes. El resultado se ve al instante, puedes seguir los valores de los sensores en el escenario y hacer que el Arduino hable con los objetos, pero en cuanto desconectas el cable USB o cierras mBlock, el programa se detiene. En el modo carga (Upload), los bloques se traducen a Arduino C, se compilan y se graban de forma permanente en la placa; aunque quites el cable, el programa sigue funcionando con una pila o un adaptador. En este modo, el programa debe ir debajo del bloque de sombrero when Arduino Uno starts up (al iniciar Arduino Uno); los eventos del escenario, como la bandera verde, no pasan a la placa.

Cargar el firmware: preparar el Arduino para el modo en vivo

1. Conecta el Arduino (Connect) y pon el interruptor de modo en Live (en vivo).
2. Si la placa no tiene el firmware de mBlock, mBlock suele proponer actualizarlo. Si no lo hace, elige Update Firmware (actualizar firmware) en el menú Setting (ajustes) que hay junto a los botones de conexión e inicia la actualización en la ventana que se abre.
3. Durante la carga, los LED TX y RX de la placa parpadean rápido; no desconectes el cable ni cierres mBlock hasta que termine la barra de progreso.
4. Para probarlo, arrastra el bloque set digital pin (13) output as (high) de los bloques de pines al área de programación y haz clic en él una vez. Si el LED L de la placa se enciende enseguida, el modo en vivo funciona; al hacer clic en el mismo bloque con la opción (low), el LED se apaga.

Bloques básicos de Arduino: LED, pulsador y sensores

Al añadir el Arduino Uno, la paleta de bloques suma categorías propias de la placa para los pines y el puerto serie, junto a las categorías Events (eventos), Control, Operators (operadores), Variables y My Blocks (mis bloques) que ya conoces de Scratch. Con la interfaz en español, los bloques aparecen con nombres en español; para que no te confundas, en la tabla siguiente tienes sus nombres en inglés y lo que hace cada uno. Los nombres pueden variar un poco según la versión; si haces clic derecho en cualquier bloque y eliges Help (ayuda), mBlock muestra su descripción. En el Uno, el PWM solo funciona en los pines 3, 5, 6, 9, 10 y 11; puedes ver el mapa completo de pines en la herramienta Pinout.

Tabla de conexiones: un único montaje para todas las actividades

Montar el circuito desde cero cada semana hace perder tiempo de clase. Si montas una vez en la protoboard las conexiones de abajo, podrás hacer las nueve actividades sin tocar un cable. Puedes comprobar la resistencia del LED con la calculadora de resistencia para LED y la tensión que da el divisor de la LDR con la herramienta de divisor de tensión. Si usas estas piezas por primera vez, en los artículos sobre el LED, el pulsador, la LDR y el servomotor tienes la conexión detallada de cada una.

Primer programa: hacer parpadear un LED en modo carga

1. Pon el interruptor de modo en Upload (carga).
2. Arrastra al área de programación el bloque when Arduino Uno starts up de la categoría Events.
3. Engancha debajo un bloque forever (por siempre) de la categoría Control.
4. Dentro de forever, coloca por este orden set digital pin (13) output as (high), wait (1) seconds, set digital pin (13) output as (low) y otra vez wait (1) seconds.
5. Pulsa Upload (cargar). mBlock compila el código y lo envía a la placa; a los pocos segundos aparece un mensaje que indica que la carga ha terminado.
6. El LED L de la placa empieza a parpadear una vez por segundo. Si desconectas el cable USB y alimentas la placa con una batería externa (powerbank) o un adaptador de 7–12 V, el programa sigue funcionando; las opciones de alimentación las explicamos en alimentar Arduino con pilas.

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

En modo carga, pulsa el botón de código Arduino C del borde derecho (el icono con corchetes angulares) y mBlock muestra en un panel el código que corresponde a tus bloques. Cada cambio en los bloques actualiza el código al momento; es la forma más fácil de aprender qué bloque genera cada línea. Si al programa Blink anterior le añades una variable llamada sayac (contador) y la aumentas en 1 en cada vuelta, el código generado se parece a este. Las líneas de comentario las hemos añadido nosotros; los espacios y la posición de algunas líneas, como pinMode, pueden cambiar un poco según la versión.

1// generated by mBlock5 for <your product>
2// codes make you happy
3// mBlock'un ürettiği kodun yapısı: Blink + sayaç / Structure of mBlock-generated code: Blink + counter
4
5#include <Arduino.h>
6#include <Wire.h>
7#include <SoftwareSerial.h>
8
9float sayac = 0;               // mBlock değişkenleri float olur / mBlock variables become float
10
11void _loop();                  // ön bildirim, Arduino IDE de ekler / forward declaration, the Arduino IDE adds it too
12
13void _delay(float seconds) {   // "wait (1) seconds" bloğu / the "wait (1) seconds" block
14  long endTime = millis() + seconds * 1000;
15  while (millis() < endTime) _loop();
16}
17
18void setup() {                 // "when Arduino Uno starts up" altındaki bloklar / blocks under "when Arduino Uno starts up"
19  pinMode(13, OUTPUT);
20  while (1) {                  // "forever" bloğu / the "forever" block
21    digitalWrite(13, 1);       // pin 13 HIGH: dahili L LED'i yanar / pin 13 HIGH: the built-in L LED turns on
22    _delay(1);
23    digitalWrite(13, 0);       // pin 13 LOW: LED söner / pin 13 LOW: the LED turns off
24    _delay(1);
25    sayac += 1;                // "change sayac by 1" bloğu / the "change sayac by 1" block
26    _loop();
27  }
28}
29
30void _loop() {                 // uzantıların sürekli çalışan kodu buraya eklenir / extensions add their recurring code here
31}
32
33void loop() {
34  _loop();
35}

En este código hay cuatro cosas en las que fijarse. Primero, el bloque forever no se convierte en la función loop() de Arduino, sino en un bucle infinito while(1) dentro de setup(); loop() solo llama a la función _loop(). Segundo, el bloque wait usa una función _delay() en lugar de delay(); mientras espera, sigue llamando a _loop(), para que las tareas que algunas extensiones hacen en segundo plano no se interrumpan. Tercero, cada variable que creas en mBlock se declara como float (número decimal); en el Uno cada una ocupa 4 bytes de RAM y puede provocar pequeños errores de redondeo al comparar igualdades. Por ejemplo, una variable que aumentas de 0,1 en 0,1 puede no valer exactamente 1 tras diez pasos, así que es más seguro comparar con "mayor que" o "menor que" que con "igual a". Cuarto, las librerías Wire y SoftwareSerial del principio suelen incluirse aunque no las uses; el programa funciona igual, pero puede ocupar algo más que una versión escrita a mano.

Actividades de ejemplo para clases de robótica y programación

Las nueve actividades siguientes están ordenadas de la más fácil a la más difícil para sesiones de 40 minutos, y todas funcionan con el mismo montaje de arriba. Empezar cada actividad en modo en vivo es una buena idea: el alumnado hace clic en un bloque, ve el resultado al instante, sigue los valores de los sensores en el escenario y encuentra sus propios errores. Cuando el programa funciona como debe, pasar esos mismos bloques al modo carga y grabarlos en la placa enseña la idea de "un aparato que funciona sin ordenador". Los conceptos de programación de estas actividades también los tienes en código de texto en el artículo fundamentos de programación de Arduino.

Las conversiones numéricas son la parte más didáctica de las clases. El potenciómetro da valores de 0 a 1023 mientras que el PWM espera de 0 a 255; por eso, en la actividad 5 divides la lectura entre 4 (1023 ÷ 4 ≈ 255). Para convertir ese mismo valor en un ángulo para el servo, montas con bloques de operadores valor × 180 ÷ 1023. En la actividad 9 le das al Arduino, en modo en vivo, el programa "when green flag clicked, forever, set [pot] to (read analog pin A1)"; en el objeto usas la misma variable en un bloque set x to (pot × 480 ÷ 1023 − 240) para repartir la raqueta por todo el ancho del escenario, de −240 a 240. Si al crear la variable no marcas la opción "para todos los objetos", el dispositivo y el objeto no ven la misma variable. Para el sensor de aparcamiento, abre el centro de extensiones con el botón + extension (extensión) de la parte inferior de la paleta y añade una extensión de sensor ultrasónico; la mayoría de estas extensiones las hacen desarrolladores de la comunidad, así que los nombres de los bloques y los pines admitidos cambian de una a otra. Cómo funciona el sensor lo explicamos en el artículo del sensor de distancia HC-SR04, y las frecuencias de las notas en el del zumbador.

Pasar al Arduino IDE: de los bloques al código real

Llega un momento en que los bloques no bastan: al crecer el programa el área de trabajo se llena, necesitas una librería de sensor que no está en el centro de extensiones o quieres hacer varias tareas a la vez sin usar delay. Es el momento de la instalación del Arduino IDE y de pasar al código de texto; añadir librerías para sensores nuevos pasa a estar en tus manos. La mejor forma de suavizar el cambio es reescribir en el Arduino IDE un proyecto que hayas hecho en mBlock; así ves dos versiones de la misma lógica una al lado de la otra.

1. En mBlock, selecciona y copia el código del panel Arduino C; abre un sketch nuevo en el Arduino IDE y pégalo.
2. En el menú Herramientas, elige la placa (Arduino Uno) y el puerto; pulsa primero Verificar y después Subir. El código debería funcionar igual que en mBlock.
3. Después simplifica el código: reúne las líneas pinMode en setup(), pasa el contenido del bucle while(1) a loop() y usa delay() o millis() en lugar de _delay().
4. Cambia las variables float por int o bool según convenga y da nombres claros a los números de pin con const int.
5. Muestra variables en el Monitor Serie para seguir lo que hace el programa; es el equivalente en código de texto de la monitorización en vivo de mBlock.

A continuación tienes el programa que une las actividades 3 y 4, una luz nocturna automática que se activa y desactiva con un pulsador, escrito para el Arduino IDE. Los números de pin coinciden con la tabla de conexiones de arriba.

1// mBlock gece lambası etkinliğinin Arduino IDE ile yazılmış hali
2// The mBlock night-light activity rewritten for the Arduino IDE
3const int LED_PIN = 5;         // LED + 220 ohm direnç (PWM pini) / LED + 220 ohm resistor (PWM pin)
4const int BUTON_PIN = 2;       // buton 5V'a, 10k pull-down GND'ye / button to 5V, 10k pull-down to GND
5const int LDR_PIN = A0;        // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
6const int ESIK = 400;          // bu değerin altı "karanlık" sayılır / below this value counts as "dark"
7
8bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
9int oncekiButon = LOW;         // önceki buton durumu / previous button state
10unsigned long sonYazma = 0;    // son Seri Monitör yazma zamanı / last Serial Monitor print time
11
12void setup() {
13  pinMode(LED_PIN, OUTPUT);
14  pinMode(BUTON_PIN, INPUT);   // harici pull-down olduğu için INPUT / INPUT because of the external pull-down
15  Serial.begin(9600);          // Seri Monitör 9600 baud / Serial Monitor at 9600 baud
16}
17
18void loop() {
19  int buton = digitalRead(BUTON_PIN);
20  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
21    sistemAcik = !sistemAcik;
22    delay(30);                                 // basit debounce / simple debounce
23  }
24  oncekiButon = buton;
25
26  int isik = analogRead(LDR_PIN);              // 0 karanlık, 1023 aydınlık / 0 dark, 1023 bright
27  if (sistemAcik && isik < ESIK) {
28    int parlaklik = map(isik, 0, ESIK, 255, 40);   // karardıkça daha parlak / brighter as it gets darker
29    analogWrite(LED_PIN, parlaklik);
30  } else {
31    analogWrite(LED_PIN, 0);
32  }
33
34  if (millis() - sonYazma >= 500) {            // delay olmadan yarım saniyede bir yaz / print every half second without delay
35    sonYazma = millis();
36    Serial.print("Isik: ");
37    Serial.print(isik);
38    Serial.print("  Sistem: ");
39    Serial.println(sistemAcik ? "acik" : "kapali");
40  }
41}

Fíjate en las diferencias con la versión de mBlock: setup() se ejecuta una sola vez y prepara los pines, y loop() se repite por sí sola, así que no hace falta while(1). El pulsador se compara con su estado anterior y solo cuenta en el momento de pulsarlo; si no, mientras tuvieras el dedo encima, el sistema se encendería y apagaría cientos de veces por segundo. La función map() escala el valor de la LDR entre 255 y 40, de modo que el LED brilla más cuanto más oscuro está. La escritura en el Monitor Serie se hace cada medio segundo con millis() en lugar de delay(), para que el programa no se pierda una pulsación mientras espera. Tienes los detalles de esta técnica en millis frente a delay, y cómo mostrar datos en el artículo del Monitor Serie de Arduino.

El mismo programa en el ESP32 y la Raspberry Pi Pico

En la biblioteca de dispositivos de mBlock están las placas propias de Makeblock basadas en ESP32, como CyberPi y HaloCode, pero no hay un dispositivo oficial para una placa de desarrollo ESP32 normal ni para la Raspberry Pi Pico; las extensiones de la comunidad que aparecen de vez en cuando cambian además de una versión a otra. La buena noticia es que la lógica que has aprendido con bloques no cambia de una placa a otra. Al programar el ESP32 con el Arduino IDE usas casi el mismo código; solo cambian los números de pin, la tensión de trabajo de 3,3 V y la escala de 12 bits del ADC, de 0 a 4095. Por eso el umbral de oscuridad pasa de 400 a unos 1600.

1// Aynı gece lambası ESP32'de (Arduino IDE) / The same night light on the ESP32 (Arduino IDE)
2const int LED_PIN = 18;        // LED + 220 ohm direnç / LED + 220 ohm resistor
3const int BUTON_PIN = 4;       // buton 3V3'e, 10k pull-down GND'ye / button to 3V3, 10k pull-down to GND
4const int LDR_PIN = 34;        // ADC1 girişi, LDR + 10k bölücü (3V3) / ADC1 input, LDR + 10k divider (3V3)
5const int ESIK = 1600;         // ESP32 ADC 12 bit: 0-4095 / ESP32 ADC is 12-bit: 0-4095
6
7bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
8int oncekiButon = LOW;         // önceki buton durumu / previous button state
9unsigned long sonYazma = 0;    // son yazma zamanı / last print time
10
11void setup() {
12  pinMode(LED_PIN, OUTPUT);
13  pinMode(BUTON_PIN, INPUT);   // harici pull-down / external pull-down
14  Serial.begin(115200);        // ESP32 için yaygın hız / common speed for the ESP32
15}
16
17void loop() {
18  int buton = digitalRead(BUTON_PIN);
19  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
20    sistemAcik = !sistemAcik;
21    delay(30);                                 // basit debounce / simple debounce
22  }
23  oncekiButon = buton;
24
25  int isik = analogRead(LDR_PIN);              // 0 karanlık, 4095 aydınlık / 0 dark, 4095 bright
26  if (sistemAcik && isik < ESIK) {
27    analogWrite(LED_PIN, map(isik, 0, ESIK, 255, 40));   // karardıkça daha parlak / brighter as it gets darker
28  } else {
29    analogWrite(LED_PIN, 0);
30  }
31
32  if (millis() - sonYazma >= 500) {            // yarım saniyede bir yaz / print every half second
33    sonYazma = millis();
34    Serial.printf("Isik: %d  Sistem: %s\n", isik, sistemAcik ? "acik" : "kapali");
35  }
36}

En la Raspberry Pi Pico lo más habitual es MicroPython. El programa siguiente, que ejecutas en el editor Thonny, hace lo mismo: read_u16() devuelve el valor del ADC de 0 a 65535 y duty_u16() espera el ciclo de trabajo del PWM en la misma escala. Por qué Python es un buen segundo paso después de la programación por bloques lo contamos en el artículo de fundamentos de MicroPython.

1# Aynı gece lambası Raspberry Pi Pico'da (MicroPython) / The same night light on Raspberry Pi Pico (MicroPython)
2from machine import Pin, ADC, PWM
3import time
4
5led = PWM(Pin(14))                     # LED + 220 ohm direnç / LED + 220 ohm resistor
6led.freq(1000)                         # PWM frekansı 1 kHz / PWM frequency 1 kHz
7buton = Pin(2, Pin.IN, Pin.PULL_DOWN)  # buton 3V3'e, pull-down / button to 3V3, pull-down
8ldr = ADC(26)                          # GP26 = ADC0, LDR + 10k bölücü / GP26 = ADC0, LDR + 10k divider
9ESIK = 25000                           # 0-65535 arası karanlık eşiği / darkness threshold on 0-65535
10
11sistem_acik = True                     # butonla açılıp kapanır / toggled with the button
12onceki = 0                             # önceki buton durumu / previous button state
13son_yazma = time.ticks_ms()            # son yazma zamanı / last print time
14
15while True:
16    b = buton.value()
17    if b == 1 and onceki == 0:         # yalnız basıldığı an / only at the moment of the press
18        sistem_acik = not sistem_acik
19        time.sleep_ms(30)              # basit debounce / simple debounce
20    onceki = b
21
22    isik = ldr.read_u16()              # 0 karanlık, 65535 aydınlık / 0 dark, 65535 bright
23    if sistem_acik and isik < ESIK:
24        # karardıkça daha parlak / brighter as it gets darker
25        led.duty_u16(65535 - isik * 55000 // ESIK)
26    else:
27        led.duty_u16(0)
28
29    if time.ticks_diff(time.ticks_ms(), son_yazma) >= 500:   # yarım saniyede bir / every half second
30        son_yazma = time.ticks_ms()
31        print("Isik:", isik, " Sistem:", "acik" if sistem_acik else "kapali")

Abrir los mismos proyectos en bloques desde el móvil

Si quieres seguir con la lógica de bloques que montaste en mBlock cuando no estás delante del ordenador, échale un vistazo a la app BlueGrays. El código de más de 100 proyectos de Arduino, ESP32 y Raspberry Pi Pico de la app también está en nuestros propios bloques basados en Blockly. Activa Ver en bloques en un proyecto y, en lugar del código, aparece el mismo programa en bloques; la pestaña Entiende los bloques explica paso a paso qué hace cada bloque. Las actividades de LED, semáforo, LED con pulsador, luz nocturna con LDR, zumbador, sensor de aparcamiento y servo con potenciómetro de esta guía están todas allí, en bloques y en código Arduino C, y pasas de uno a otro con un toque. Comparar la secuencia que montaste en mBlock con los bloques de la app es una forma sencilla de ver cómo se construye la misma lógica en dos herramientas distintas.

Para el ESP32 y la Pico, que como hemos visto no tienen un dispositivo oficial en mBlock, la app también tiene proyectos con bloques: mira primero la versión en bloques y después pasa al código Arduino C o MicroPython del mismo proyecto. En la Guía de código de la app, los ejemplos de comandos básicos como digitalWrite, if/else y los bucles también se muestran en bloques. Si quieres afianzar lo aprendido, Preguntas del día te propone 5 preguntas diarias con niveles de A1 a C2, una clasificación semanal e insignias.

Problemas de conexión frecuentes y soluciones

Una forma rápida de saber si el problema viene de mBlock o de la placa es intentar cargar el ejemplo Blink en la misma placa con el Arduino IDE. Si el Arduino IDE también muestra un error como avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00, la placa y el ordenador no se comunican: el problema está en el puerto, el cable, el tipo de placa o el bootloader. Repasamos todas las causas de este error en la guía Arduino no sube el código; para saber más del chip CH340 y sus controladores, consulta el artículo sobre el conversor USB-TTL. Si la placa se reinicia sola con un servo conectado, te servirán los consejos de alimentación de Arduino se reinicia solo.

Ideas de proyectos con mBlock

• Semáforo con pulsador para peatones: al pulsar, el semáforo de coches pasa a rojo y se enciende el verde de peatones; para el circuito y el código, mira el artículo del semáforo con Arduino.
• Sensor de aparcamiento: un pitido que se acelera y más LED encendidos a medida que el HC-SR04 mide menos distancia.
• Robot que esquiva obstáculos: un coche con dos motores y un sensor de distancia que detecta el obstáculo y cambia de dirección; detalles en la guía del robot evita obstáculos.
• Robot siguelíneas: un robot de competición que sigue una cinta negra con sensores infrarrojos (robot siguelíneas).
• Mando para el escenario: un juego en modo en vivo en el que un potenciómetro o un joystick dirige una nave espacial por el escenario.
• Riego automático de plantas: un sistema que enciende una pequeña bomba cuando un sensor de humedad del suelo detecta tierra seca.
• Radar con servo: un proyecto que explora el entorno con un sensor de distancia montado en un servo y dibuja una pantalla de radar en el escenario (radar con Arduino).
• Coche robot: lleva la lógica de motores y sensores que aprendiste en mBlock al proyecto cómo hacer un coche robot con Arduino.

mBlock es la forma más suave de programar un Arduino de verdad con la comodidad de los bloques y de pasar al código de texto cuando estés preparado. Si aún no tienes placa, puedes probar las mismas actividades en el navegador con la simulación de Arduino en Tinkercad. En la app BlueGrays encontrarás esquemas de circuito paso a paso y código para los proyectos de LED, semáforo, LED con pulsador, luz nocturna con LDR, zumbador, sensor de aparcamiento HC-SR04 y servo con potenciómetro, y también puedes abrir esos mismos proyectos en bloques, así podrás comparar con un toque la versión en bloques y la versión en código de texto de cada actividad que montaste en mBlock.