Raspberry Pi Pico programación por bloques: sensores y MicroPython

La programación por bloques de la Raspberry Pi Pico con MicroPython resulta mucho más fácil cuando ya sabes leer un sensor con bloques. Leer un sensor con bloques significa obtener un valor sin escribir código: el bloque «leer analógico A0» toma el nivel de luz de un LDR y el bloque «imprimir en serie» envía ese número al Monitor Serie de tu ordenador. En este artículo primero leerás sensores con bloques en Arduino a través de los proyectos del LDR y del HC-SR04, comparando cada bloque con su línea analogRead(), Serial.begin(), Serial.println() o pulseIn(). Después darás el paso de la programación por bloques a MicroPython en la Raspberry Pi Pico y verás qué cambia cuando los mismos bloques se convierten en código Python.

Hasta ahora todos los programas de la serie actuaban hacia fuera: encendimos LED, leímos un pulsador y montamos un contador con un bucle. Leer un sensor funciona al revés: la placa mide el entorno y tú ves el número. Por eso aquí entra en juego el puerto serie, porque la forma más sencilla de entender qué mide un sensor es ver su valor en la pantalla. En la segunda mitad, los bloques de los proyectos de Raspberry Pi Pico corresponden a MicroPython en lugar de C++. Todos los proyectos que usamos son gratuitos en BlueGrays y el código citado es exactamente el del proyecto.

Qué significa leer un sensor: entradas digitales y analógicas

Un pulsador solo informa de dos estados: pulsado o no. Lo lees con el bloque de lectura digital de pin (digitalRead) y el resultado es 0 o 1. Componentes como un LDR, un potenciómetro o un sensor de humedad del suelo dan todos los valores intermedios: la tensión en el pin varía de forma continua entre 0 y 5 V. El circuito que convierte esa tensión en un número es el ADC (convertidor analógico-digital). El ADC del Arduino Uno es de 10 bits, así que divide la tensión en 1024 pasos y devuelve un número de 0 a 1023; cada paso equivale a unos 4,9 mV. El ESP32 y la Pico tienen ADC de 12 bits que trabajan a 3,3 V. Esta diferencia entre placas es una de las confusiones más habituales al pasar de los bloques al código; tienes los detalles en el artículo ADC y conversión analógico-digital.

Leer un LDR con bloques en Arduino

Nuestro primer ejemplo es el proyecto Medir la intensidad de luz con LDR. Un LDR es una resistencia cuyo valor baja cuando aumenta la luz; por sí solo no genera tensión. Para medirlo lo ponemos en serie con una resistencia fija de 10 kΩ, formando un divisor de tensión, y llevamos el punto medio a A0. Con el cableado de abajo el LDR queda en el lado de 5V, así que con más luz suben la tensión en A0 y la lectura; si intercambias el LDR y la resistencia, el sentido se invierte. Puedes calcular la salida del divisor para distintos valores de LDR con la calculadora de divisor de tensión y ver cuántos ohmios tiene un LDR a oscuras y con luz en el artículo sensor de luz LDR. La columna de la Pico la usaremos en el ejemplo de MicroPython del final.

Lee los bloques de arriba abajo. El bloque «declarar entero (int) value = 0» dentro de variables globales (al principio) es la línea int value; del principio del código. La sección configuración (una vez) tiene un solo bloque, «iniciar serie a 9600 baudios», es decir, Serial.begin(9600);. Dentro de repetir siempre va primero «establecer value a leer analógico A0», que es la línea value = analogRead(A0);. Luego hay dos bloques «imprimir en serie». El primero imprime el texto «Value:» con la opción continuar y se convierte en Serial.print(); el segundo imprime value con salto de línea y se convierte en Serial.println(). Así cada medida aparece en una sola línea como «Value: 512». El último bloque, «esperar 500 ms», es delay(500);, de modo que obtienes dos lecturas por segundo. Para pasar la lectura a tensión, usa value × 5,0 / 1023: 512 son unos 2,5 V. En una habitación oscura el valor baja a unos cientos y con una linterna sobre el LDR sube por encima de 900; los números exactos dependen de tu LDR y de la luz ambiente.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Abrir el Monitor Serie y ver los valores

1. Pega el código en el Arduino IDE, elige la placa y el puerto y pulsa Subir.
2. Cuando termine la carga, haz clic en el icono de la lupa arriba a la derecha o abre Herramientas > Monitor Serie (atajo Ctrl+Mayús+M).
3. Pon la velocidad en baudios del Monitor Serie igual que en el código: 9600 baudios en este proyecto.
4. Cada medio segundo aparece una línea «Value: …». Tapa el LDR con la mano y mira cómo baja el número.
5. Si quieres ver el cambio como gráfica, abre Herramientas > Serial Plotter; los mismos datos se dibujan como una línea en el tiempo.
6. Los ajustes de fin de línea y el envío de datos desde el Monitor Serie a la placa se explican en detalle en el artículo Monitor Serie de Arduino.

Distancia con el HC-SR04: esperar µs y duración del pulso

El segundo proyecto de sensores es HC-SR04 Medición de distancia (pantalla en serie). Aquí aparecen dos bloques nuevos. El trío que empieza con «escribir ALTO en pin trigPin» le dice al sensor que envíe un pulso de sonido: el bloque «esperar 10 µs» del medio es delayMicroseconds(10);, una espera mil veces más corta que «esperar … ms». Después viene «establecer duration a duración del pulso ALTO en pin echoPin (µs)», que es la línea unsigned long duration = pulseIn(echoPin, HIGH); y mide cuántos microsegundos permanece en ALTO el pin Echo. El sonido recorre en el aire unos 0,034 cm/µs, y ese tiempo incluye la ida y la vuelta. Por eso «establecer totalPath a duration × 0.034» calcula el recorrido completo y «establecer distance a totalPath ÷ 2» la distancia de ida. Por ejemplo, un pulso de 1000 µs supone 34 cm de recorrido, es decir, 17 cm de distancia; como distance es un int, se descartan los decimales. Por último, el bloque «si distance > minDistance y distance < maxDistance» se convierte en if (distance > minDistance && distance < maxDistance) y solo imprime las medidas entre 3 y 100 cm. Si el sensor no recibe eco, pulseIn() devuelve 0, y esta comprobación también deja fuera de la pantalla esos ceros falsos. En el código los pines son trigPin = 7 y echoPin = 6. El rango y la precisión del sensor están en el artículo sensor de distancia HC-SR04.

La misma idea en el ESP32: un ADC de 12 bits

La versión ESP32 de la misma lógica del LDR es el proyecto Lectura de la intensidad luminosa con el módulo LDR del ESP32. Los bloques vuelven a corresponder a C++ y se leen igual que en Arduino, con tres diferencias. Primero, setup() fija el ADC en 12 bits con analogReadResolution(12), así que analogRead() devuelve 0–4095 en lugar de 0–1023, y un umbral escrito para Arduino como «oscuro por debajo de 500» no significa lo mismo en el ESP32. Segundo, el puerto serie funciona a 115200 baudios en vez de 9600, así que pon también el Monitor Serie a 115200. Tercero, en la salida AO del módulo LDR la tensión y el valor bruto bajan cuando aumenta la luz. Por eso el código usa los valores de calibración RAW_DARK = 4000 y RAW_LIGHT = 100, mantiene la lectura en ese rango con constrain() y con map() la convierte en 0 % para oscuro y 100 % para luz. En un ESP32 DevKit clásico el LDR va al GPIO 34, un pin solo de entrada del ADC1. Como los pines del ADC2 no se pueden leer con el Wi-Fi activo, conectar los sensores analógicos a pines del ADC1 es una buena costumbre. Las características generales de la placa están en Qué es el ESP32.

De los bloques a MicroPython en la Raspberry Pi Pico

En los proyectos de la Pico los bloques corresponden a MicroPython en lugar de C++. Los bloques tienen un aspecto conocido, pero el lenguaje que hay debajo es distinto: no hay llaves ni punto y coma, los bloques de código se marcan con la sangría y no existen las funciones setup() y loop(). Hagamos el cambio con el proyecto más sencillo, Encendido de un LED externo con la Raspberry Pi Pico (GP14 + placa de pruebas). El circuito es mínimo: GP14 (pin físico 19) va a la pata larga del LED a través de una resistencia de 220–330 Ω, y la pata corta va a GND (por ejemplo, el pin físico 18). El programa enciende el LED medio segundo, lo apaga medio segundo y escribe una línea en la Shell de Thonny en cada paso. Si la Pico es nueva para ti, empieza por Qué es la Raspberry Pi Pico.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

En la tabla destacan cuatro cosas. Primero, las líneas from machine import Pin e import time no tienen bloque; en Python importas al principio los módulos que vas a usar y los bloques lo dan por hecho. Segundo, el bloque de Arduino «iniciar serie a 9600 baudios» no tiene equivalente aquí: en la Pico la salida de print() va directamente por USB a la Shell de Thonny, sin velocidad que configurar. Tercero, ha cambiado la unidad de espera: en Arduino «esperar 500 ms» es delay(500), mientras que en la Pico «esperar 0.5 segundos» es time.sleep(0.5). Cuarto, y lo más importante, la sangría: cada bloque encajado dentro de «repetir siempre» se escribe en el código cuatro espacios hacia dentro bajo la línea while True:. Si borras la sangría de una línea, esa línea sale del bucle; en Python los espacios hacen el trabajo de las llaves de C++. Encontrarás las demás reglas básicas en el artículo fundamentos de MicroPython.

Las mismas operaciones en tres lenguajes: bloques, C++ y MicroPython

Tu propio ejemplo: leer un LDR en la Pico con MicroPython

Ahora pasemos el proyecto del LDR de Arduino a la Pico. El cableado sigue la columna de la Pico de la tabla anterior: una pata del LDR al pin 3V3(OUT), la otra a GP26 y a un extremo de la resistencia de 10 kΩ, y el otro extremo de la resistencia a GND. La Pico tiene tres pines capaces de leer valores analógicos: GP26 (ADC0), GP27 (ADC1) y GP28 (ADC2). En MicroPython creas un objeto ADC(26) y llamas a read_u16(); aunque el ADC de la Pico es de 12 bits en hardware, esta función escala el resultado a 0–65535. Para obtener la tensión, multiplica el valor por 3,3 y divídelo entre 65535. El programa sigue el mismo flujo que la versión de Arduino: medir, imprimir y esperar medio segundo. Además hemos añadido un umbral: cuando la habitación se oscurece, se enciende el LED integrado. Pensando en bloques, las líneas antes de while True son la sección «configuración (una vez)», while True: es «repetir siempre», el if/else es el bloque «si» de la parte 3 de la serie, led.on() es «encender (on) el pin led», time.sleep(0.5) es «esperar 0.5 segundos» y el + str() dentro de print() es el bloque «crear texto con». La línea ADC(26).read_u16() hace el trabajo del bloque «leer analógico A0» de Arduino. Ajusta THRESHOLD a los números que veas en la Shell en tu propia habitación.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Cargar el código en la Pico con Thonny y main.py

1. Instala Thonny en tu ordenador. Si la Pico aún no tiene MicroPython, mantén pulsado el botón BOOTSEL mientras conectas el cable USB; Thonny te ofrecerá instalar MicroPython en la primera conexión.
2. En la esquina inferior derecha de Thonny elige MicroPython (Raspberry Pi Pico) como intérprete. Si ves el indicador >>> en la Shell de abajo, la conexión está lista.
3. Copia el código del proyecto desde BlueGrays y pégalo en el editor de Thonny.
4. Pulsa el botón verde de ejecutar o F5. El código se ejecuta en la Pico y la salida de print() aparece en la Shell. Para detenerlo usa el botón de parar (Ctrl+F2).
5. Si quieres que el código funcione sin ordenador, elige Archivo > Guardar como, selecciona Raspberry Pi Pico en el cuadro de diálogo y llama al archivo main.py. La Pico ejecuta este archivo automáticamente cada vez que recibe alimentación, así que basta con un cargador USB o una batería externa.
6. Si Thonny no detecta la placa, revisa el cable y los controladores en el orden del artículo la Raspberry Pi Pico no se reconoce.

Más proyectos de bloques gratuitos para la Pico

• Parpadeo del LED integrado de la Raspberry Pi Pico (GP25): no necesita ningún cable; hace parpadear el LED de la placa con LED_PIN = 25. El código es casi idéntico al del proyecto anterior: ábrelos uno al lado del otro y verás que solo cambia el número de pin. En la Pico W el LED integrado está conectado al chip Wi-Fi, así que se usa Pin("LED").
• Raspberry Pi Pico Dos LEDs alternos (GP14 + GP13): empieza con estados opuestos mediante led1.value(1) y led2.value(0) y en el bucle aplica toggle() a los dos LED. Como el código usa from time import sleep, la espera aparece como sleep(0.5) en lugar de time.sleep(0.5).
• Simulador de semáforo con Raspberry Pi Pico (GP11/GP12/GP13): una función llamada all_off() apaga todos los LED; el verde se queda encendido 4 segundos, el amarillo 1,5 y el rojo 3, y después llega una fase de arranque rojo+amarillo de 1 segundo.
• Raspberry Pi Pico Efecto luces policía (GP11 + GP12): esta vez la espera va en milisegundos con sleep_ms(WAIT_MS), donde WAIT_MS = 300. Ver las funciones de segundos y de milisegundos en dos proyectos distintos es la mejor forma de evitar el error más común de la lista siguiente.

Errores frecuentes y cómo solucionarlos

Seguir con bloques en la app BlueGrays

Todos los proyectos de este artículo son gratuitos en la app BlueGrays. Al activar el interruptor Ver en bloques en la sección de código de un proyecto, el código se sustituye por el mismo programa en bloques; toca la imagen para abrirla a pantalla completa. La pestaña Entiende los bloques explica el programa paso a paso y en cada paso muestra solo los bloques de ese paso y lo que hacen. Ahí puedes ver con calma qué mide el bloque de duración del pulso en el proyecto del HC-SR04 o por qué la parte de configuración de un proyecto de la Pico va antes de while True. Todos los ejemplos de comandos de Arduino y MicroPython de la Guía de código también se muestran en bloques. Para poner a prueba lo aprendido, las Preguntas del día te dan 5 preguntas diarias de A1 a C2, una clasificación semanal e insignias. Recuerda que los bloques nunca se cargan directamente en la placa: la placa siempre recibe el código real del proyecto, que copias en el Arduino IDE para Arduino y ESP32 o en Thonny para la Pico. Puedes filtrar la lista de proyectos por la insignia de bloques y encontrar todos los proyectos con bloques para Arduino, ESP32 y Pico en la página de programación por bloques.

Con el puerto serie y la lectura de sensores ya puedes leer todas las piezas básicas de un proyecto tanto en bloques como en código. La última parte de la serie lleva estos pasos al aula: un plan de clase de robótica con programación por bloques para docentes. Mientras tanto, en la app BlueGrays puedes repasar paso a paso los esquemas y el código de los proyectos del LDR, del HC-SR04 y del LED con la Pico, pasar a la versión en bloques del mismo programa con Ver en bloques y seguir lo que hace cada paso con Entiende los bloques.