Raspberry Pi Pico 2 W desde cero: MicroPython, Thonny, sensor interno y WiFi

¿Tienes un Raspberry Pi Pico 2 W recién salido de la bolsa antiestática y no sabes por dónde partir? La buena noticia es que en unos veinte minutos lo puedes tener corriendo MicroPython, parpadeando su LED, leyendo su propia temperatura y conectado al WiFi de tu casa. Esta guía está ordenada por bloques: primero entiendes qué es (y qué no es) el Pico, después preparas el entorno, luego lo pruebas con tres programas cortos y al final ves los detalles que más hacen tropezar a quien recién empieza, incluido un error de hardware del RP2350 que conviene conocer antes de cablear tu primer botón.

Al terminar vas a saber flashear MicroPython de dos formas, usar Thonny como editor y consola, dejar un programa que arranca solo con main.py, conectarte a una red de 2,4 GHz y dejar el Pico listo para mandar datos a un servidor como Home Assistant.

El concepto: un microcontrolador, no un computador chico

El nombre confunde: el Pico no es un Raspberry Pi en miniatura. Un Raspberry Pi 5 corre Linux, tiene escritorio, salida de video y decenas de procesos a la vez. El Pico es un microcontrolador: no tiene sistema operativo, ejecuta un solo programa y arranca en una fracción de segundo. Tampoco necesita "apagarse": le puedes desconectar el cable cuando quieras sin corromper nada, porque no hay un sistema de archivos abierto como en Linux.

Esa simplicidad es justamente su gracia. Reacciona a lo que pasa en sus pines en microsegundos, consume muy poco y maneja LEDs, relés, botones y sensores directamente. Sirve para nodos de sensores que reportan por WiFi, controles con pantallas, tiras LED, control de motores o pequeños dispositivos USB. Si lo que necesitas es un servidor, procesar video de una cámara o un reproductor multimedia, ahí corresponde un Raspberry Pi. Lo más común en la práctica es combinarlos: el Pi recolecta y guarda los datos, y uno o varios Picos los miden en terreno.

¿Qué modelo de Pico elegir?

Los cuatro modelos comparten el mismo formato (51 × 21 mm, del tamaño de un chicle en barra) y la misma distribución de pines, así que un proyecto se traslada de uno a otro casi sin cambios. Lo que cambia es el chip y la radio:

Para empezar, la recomendación es el Pico 2 W: el doble de RAM y de flash que el Pico W, más potencia y WiFi incluido. El WiFi lo vas a querer apenas pienses en mandar mediciones a otro lado. Si no quieres soldar, busca la variante con "H" en el nombre (Pico 2 WH), que trae los pines ya soldados y entra directo en la protoboard.

Un detalle técnico que vale la pena entender: el RP2350 trae dos pares de núcleos, dos ARM Cortex-M33 y dos RISC-V Hazard3, pero solo usa un par a la vez. Cuál se usa lo decide el binario que cargas al arrancar. MicroPython para el Pico 2 W corre por defecto en los núcleos ARM, así que para esta guía no tienes que hacer nada; es un dato útil cuando más adelante veas firmwares compilados "para RISC-V".

El hardware que necesitas

• Un Raspberry Pi Pico 2 W (para los ejemplos de WiFi tiene que ser un modelo W).
• Un cable micro USB que transmita datos. Este es el punto donde más gente se queda pegada: muchos cables que vienen con cargadores solo tienen los hilos de alimentación, y con ellos el Pico ni siquiera aparece en el computador.
• Un computador con Windows, macOS o Linux. Un Raspberry Pi con escritorio también sirve.
• Para los ejemplos de esta guía, nada más: el LED y el sensor de temperatura vienen en la placa. Para tus propios circuitos después: una protoboard, cables jumper, algunos LEDs con resistencias y un pulsador.

El software: MicroPython y Thonny

Paso 1: flashear MicroPython

De fábrica el Pico viene vacío. Para que entienda Python hay que cargarle el firmware de MicroPython, y eso no requiere drivers ni programas especiales, porque en el llamado modo BOOTSEL el Pico se presenta como un pendrive.

1. Descarga desde micropython.org el firmware estable de tu modelo. Para el Pico 2 W es el archivo RPI_PICO2_W-…-v1.29.0.uf2. Evita los builds "preview", que son versiones de desarrollo. Los nombres para los otros modelos están en la tabla de arriba.
2. Conecta el Pico por USB. Uno nuevo arranca solo en modo BOOTSEL porque no tiene firmware en la flash. Si ya tenía algo cargado, mantén presionado el botón blanco BOOTSEL, conecta el cable y suelta el botón recién después.
3. Aparece una unidad nueva llamada RP2350 (en el Pico y Pico W se llama RPI-RP2) con dos archivos: INDEX.HTM e INFO_UF2.TXT. Que tengan fecha de 2008 es normal: esa fecha está grabada en la ROM de arranque.
4. Arrastra el archivo .uf2 a esa unidad. A los pocos segundos desaparece, el Pico se reinicia y ya está corriendo MicroPython.

¿Por qué funciona sin drivers? El formato UF2 fue diseñado justo para esto: el chip emula un disco USB de almacenamiento masivo (una clase que todos los sistemas operativos reconocen de serie) y cada bloque del archivo .uf2 trae la dirección de flash donde debe escribirse. El bootloader, que vive en la ROM y no se puede borrar, simplemente va copiando bloques. Por eso es imposible "brickear" un Pico con un firmware malo: el modo BOOTSEL siempre sigue ahí.

Paso 2: instalar y conectar Thonny

Thonny es un editor de Python gratuito que trabaja directo con placas MicroPython: escribes el código, lo ejecutas en el Pico con un clic y copias archivos a la placa. En Raspberry Pi OS con escritorio ya viene instalado; en otros sistemas, descárgalo desde su sitio.

1. En Thonny abre Tools → Options y ve a la pestaña Interpreter.
2. Elige MicroPython (Raspberry Pi Pico).
3. En el puerto deja Try to detect port automatically y confirma con OK.

Abajo, en la consola (Shell), aparece el saludo de MicroPython con la versión y la placa, algo como MicroPython v1.29.0 on 2026-08-24; Raspberry Pi Pico 2 W with RP2350. En la esquina inferior derecha Thonny muestra el intérprete activo y el puerto; en Windows será un puerto COM, como Board CDC @ COM5.

Hay un atajo que te ahorra el Paso 1, sobre todo para actualizar más adelante: en ese mismo diálogo está el enlace Install or update MicroPython. Con el Pico en modo BOOTSEL, Thonny detecta la unidad solo; eliges como familia RP2, como variante tu modelo (por ejemplo Raspberry Pi • Pico 2 W), la versión más nueva, y haces clic en Install.

Para comprobar que todo responde, escribe estas tres líneas en el editor y presiona el botón verde de ejecutar:

import sys, os
print(sys.implementation)
print(os.uname())

La salida indica versión, placa y build del firmware. El MPY: soft reboot que aparece antes no es un error: Thonny reinicia el intérprete antes de cada ejecución para que no queden restos del programa anterior.

MPY: soft reboot
(name='micropython', version=(1, 29, 0, ''), _machine='Raspberry Pi Pico 2 W with RP2350', _mpy=7942, _build='RPI_PICO2_W', _thread='unsafe')
(sysname='rp2', nodename='rp2', release='1.29.0', version='v1.29.0 on 2026-08-24 (GNU 16.1.0 MinSizeRel)', machine='Raspberry Pi Pico 2 W with RP2350')

Las pruebas: LED, temperatura y WiFi

Paso 3: el LED que parpadea

El "hola mundo" de los microcontroladores. El Pico tiene un LED verde justo al lado del conector USB:

from machine import Pin
import time

led = Pin("LED", Pin.OUT)
while True:
    led.toggle()
    time.sleep(0.5)

Usa siempre Pin("LED") y no un número. En el Pico y el Pico 2 el LED está en el GPIO 25, pero en los modelos W está conectado al chip de WiFi, no al microcontrolador. Por eso los tutoriales antiguos con Pin(25) dejan apagado el LED de un Pico W o Pico 2 W. El nombre "LED" lo resuelve MicroPython según la placa. Para detener el programa, usa el botón rojo de Stop de Thonny.

Que el programa arranque solo: main.py

Mientras ejecutes el código con el botón verde, vive en la RAM y se pierde al desconectar. Para que corra cada vez que el Pico se energiza, guárdalo con File → Save as, elige Raspberry Pi Pico (no "This computer") y nómbralo main.py. MicroPython ejecuta ese archivo automáticamente al arrancar. Desde ahí el Pico funciona con cualquier cargador USB o power bank, sin computador.

Si el main.py tiene un ciclo infinito, Thonny lo interrumpe al conectarse siempre que esté marcada la opción Interrupt working program on connect en las opciones del intérprete. Para borrarlo, abre View → Files, haz clic derecho sobre el archivo en la sección del Pico y elimínalo.

Paso 4: leer el sensor de temperatura interno

El RP2040 y el RP2350 traen un sensor de temperatura que se lee por el conversor analógico digital (ADC), canal 4. La fórmula de voltaje a grados sale de la hoja de datos del RP2350:

from machine import ADC

sensor = ADC(4)
voltage = sensor.read_u16() * 3.3 / 65535
temperature = 27 - (voltage - 0.706) / 0.001721
print(f"{temperature:.1f} °C")

Ojo con interpretar ese número: el sensor mide la temperatura del chip, no la del aire. En la prueba del autor original, el Pico 2 W marcó 35,5 °C con la pieza a unos 22,5 °C, unos 13 grados de más. Hay dos razones físicas:

• El chip se calienta solo. El sensor es un diodo dentro del silicio, pegado a los núcleos que trabajan. Con el WiFi encendido la diferencia crece.
• La referencia del ADC no es exacta. La fórmula asume exactamente 3,3 V, pero el ADC del Pico no tiene referencia propia: usa su alimentación filtrada, que según la hoja de datos del Pico 2 queda unos 30 mV por debajo por la resistencia del filtro. Como la pendiente del sensor es de apenas 1,721 mV por grado, un error de 1 mV ya mueve el resultado más de medio grado. Por eso el sensor interno nunca va a ser un termómetro de precisión, por bien que lo programes.

Para ver tendencias (por ejemplo, si el chip se calienta dentro de una caja) sirve tal cual. Si quieres un valor absoluto razonable, promedia varias lecturas para bajar el ruido y calibra una vez contra un termómetro:

from machine import ADC
import time

OFFSET = -13.0  # thermometer reading minus Pico reading, measure once per board

sensor = ADC(4)
total = 0
for _ in range(20):
    total += sensor.read_u16()
    time.sleep_ms(10)
voltage = total / 20 * 3.3 / 65535
temperature = 27 - (voltage - 0.706) / 0.001721 + OFFSET
print(f"{temperature:.1f} °C")

El OFFSET lo tienes que medir para tu placa: los -13 son del ejemplar del autor. Y si lo que quieres es la temperatura de la pieza, lo correcto es un sensor externo, como un BME280 por I²C.

Paso 5: conectar el Pico 2 W al WiFi

Los modelos W traen un chip de radio de Infineon (el CYW43439) que MicroPython maneja con el módulo network. Escribe el nombre de tu red y la contraseña:

import network, time

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("YOUR_SSID", "YOUR_PASSWORD")
for _ in range(20):
    if wlan.isconnected():
        break
    time.sleep(0.5)
print("connected:", wlan.isconnected(), wlan.ifconfig())

El ciclo espera hasta diez segundos. En la prueba original el Pico 2 W se conectó en tres a cuatro segundos y después mostró su IP, máscara, gateway y servidor DNS.

Si sale connected: False, revisa primero nombre y contraseña. Después, la banda: el Pico solo funciona en 2,4 GHz. Los routers que juntan 2,4 y 5 GHz bajo un mismo nombre normalmente no dan problema, pero una red solo de 5 GHz no la va a ver. En Chile esto pasa bastante con los routers que instalan las compañías de fibra, que a veces dejan la red de 2,4 GHz con otro nombre (terminado en "-2G" o similar) o desactivada: entra al panel del router y confirma que existe.

Cuando el código pase a un main.py, guarda las credenciales en un archivo aparte, por ejemplo secrets.py en el Pico, e impórtalo. Así la contraseña no termina en una captura de pantalla o en un foro.

Lo que hace tropezar a los que recién empiezan

El error E9 del RP2350 y los pull down internos

La primera versión de producción del RP2350, el stepping A2, tiene un defecto de hardware documentado en la hoja de datos como erratum RP2350-E9. Cuando un GPIO está configurado como entrada y su voltaje queda en la zona indefinida entre "bajo" y "alto", sale del pin una corriente de fuga de unos 120 µA que lo deja clavado cerca de 2,2 V. El pull down interno es demasiado débil para ganarle.

En la práctica: un botón que conecta el pin a 3,3 V y depende del pull down interno puede quedar marcando "presionado" para siempre después de la primera pulsación. El problema está corregido desde el stepping A3/A4, pero el Pico 2 W del autor, comprado en otoño europeo de 2026, todavía traía un chip A2 (se reconoce por la inscripción RP2350A0A2). Puedes revisarlo por software; el script aplica solo al Pico 2 y Pico 2 W, porque el RP2040 no tiene este problema:

import machine, sys

if "RP2350" in sys.implementation._machine:
    rev = machine.mem32[0x40000000] >> 28
    version = (rev & 3) | ((rev & 8) >> 1)
    if version == 2:
        print("RP2350 A2: affected by erratum E9")
    else:
        print("RP2350 A3/A4: not affected")
else:
    print("RP2040: erratum E9 does not apply")

La lectura reproduce la función rp2350_chip_version() del Pico SDK oficial.

La solución es invertir la lógica: conecta el botón a GND y usa el pull up interno, que no tiene el defecto. El pin queda en 1 en reposo y pasa a 0 al presionar:

from machine import Pin
import time

led = Pin("LED", Pin.OUT)
button = Pin(14, Pin.IN, Pin.PULL_UP)  # button between GP14 (pin 19) and GND (pin 18)

while True:
    led.value(button.value() == 0)
    time.sleep_ms(20)

Si tu circuito necesita sí o sí un pull down, pon uno externo de 8,2 kΩ como máximo a GND: según la hoja de datos, con ese valor le gana a la corriente de fuga. La razón es simple ley de Ohm: 120 µA por 8,2 kΩ dan menos de 1 V, por debajo del umbral en que el pin lee "alto". Con 47 kΩ, en cambio, la caída se iría sobre los 5 V teóricos y el pin quedaría flotando en la zona prohibida. El sleep_ms(20) del ejemplo, de paso, hace de antirrebote básico.

Resetear el Pico o actualizar MicroPython

Actualizar es igual que instalar la primera vez: BOOTSEL presionado, conectar, arrastrar el .uf2 nuevo o usar Install or update MicroPython en Thonny. Tus archivos, como main.py, normalmente sobreviven.

Si quieres dejar el Pico completamente vacío (porque un main.py defectuoso lo cuelga al arrancar o porque vas a regalar la placa), usa el archivo oficial flash_nuke.uf2, que hoy es universal para RP2040 y RP2350. Arrastrado en modo BOOTSEL, borra toda la flash y la unidad vacía vuelve a aparecer de inmediato. Ahí partes de nuevo desde el Paso 1. El modo BOOTSEL no se puede dañar: está fijo en la ROM del chip.

Solución de problemas rápida

• No aparece la unidad: casi siempre es un cable solo de carga. Prueba con otro que sepas que transmite datos. Si el Pico ya tiene firmware, BOOTSEL tiene que estar presionado al conectar.
• Thonny no encuentra el Pico: revisa abajo a la derecha que esté elegido el intérprete MicroPython. Si otro programa ocupa el puerto (una segunda ventana de Thonny, el monitor serie de la Arduino IDE), ciérralo y presiona Stop en Thonny.
• Thonny dice Connection lost — EOF: pasa cuando el Pico se reinicia o entra en BOOTSEL con Thonny conectado. Cuando MicroPython vuelva a correr, reconéctate con el botón Stop.
• La unidad desaparece después de copiar: es lo esperado. El Pico se reinicia con el firmware nuevo y queda como dispositivo serie, no como unidad.
• El LED no enciende: si el código dice Pin(25), cámbialo por Pin("LED"). Revisa también que cargaste el firmware del modelo correcto: el firmware del Pico 2 sin W no conoce el chip WiFi, que es donde está el LED del Pico 2 W.

Preguntas frecuentes

¿Puede correr Linux o Raspberry Pi OS en el Pico? No. Con 264 o 520 KB de RAM ejecuta un solo programa, escrito en MicroPython, C/C++ o con la Arduino IDE. Para Linux necesitas un Raspberry Pi como el Pi 5 o el Zero 2 W.

¿Qué diferencia hay entre el Pico W y el Pico 2 W? Ambos tienen WiFi, Bluetooth y los mismos pines. El Pico 2 W usa el RP2350 (150 MHz, 520 KB de RAM, 4 MB de flash) y el Pico W el RP2040 (133 MHz, 264 KB, 2 MB). El código MicroPython del Pico W normalmente corre sin cambios en el Pico 2 W.

¿Lo puedo programar con la Arduino IDE? Sí. Desde el gestor de placas instalas el paquete Raspberry Pi Pico/RP2040/RP2350 de Earle Philhower, que soporta los cuatro modelos con WiFi. Volver a MicroPython es tan simple como cargar de nuevo su firmware.

¿Puedo conectar sensores de 5 V directo a los GPIO? En el Pico y el Pico W no: sus GPIO aguantan solo 3,3 V. En el Pico 2 y Pico 2 W los pines digitales toleran 5 V, pero solo mientras la placa esté energizada, y los pines del ADC (GP26 a GP28) no los toleran nunca. Lo seguro en cualquier modelo es un conversor de nivel lógico o un divisor de voltaje.

Variantes y mejoras

• Un nodo de temperatura para Home Assistant. Ya tienes las dos piezas: la lectura del sensor y el WiFi. Lo que falta es el transporte. La forma más limpia es MQTT: instala el complemento Mosquitto en Home Assistant, copia al Pico la librería umqtt.simple (está en micropython-lib y Thonny la instala desde Tools → Manage packages) y publica cada minuto la temperatura en un tópico como casa/pico/temperatura. Si además publicas una vez el mensaje de configuración de MQTT Discovery, el sensor aparece solo en Home Assistant, con historial y gráficos, sin escribir YAML. Para que el dato sea útil, reemplaza el sensor interno por un BME280 o un DS18B20.
• Ahorro de energía para usarlo con pilas. En vez de un while True con sleep, usa machine.lightsleep() entre mediciones y apaga la radio con wlan.active(False) cuando no transmite. El WiFi es lo que más consume; encenderlo solo para enviar cambia drásticamente la autonomía con un portapilas de 3 AA o una batería LiPo.
• Un panel en la misma red. Con el módulo socket (o la librería Microdot) el Pico puede servir una página web mínima con la temperatura y un botón para encender el LED, accesible desde el celular en la misma red WiFi.

Personalización para Chile

En Chile consigues lo necesario para esta guía en MechatronicStore. Busca en el catálogo:

• Raspberry Pi Pico 2 W: la placa de todo el tutorial. Si prefieres no soldar, la versión con pines soldados (Pico 2 WH) entra directo en la protoboard.
• Raspberry Pi Pico W: alternativa con RP2040. Todo el código de esta guía corre igual; solo cambia el firmware (RPI_PICO_W) y el nombre de la unidad en modo BOOTSEL (RPI RP2).
• Cable micro USB de datos: asegúrate de que diga datos, no solo carga.
• Protoboard 830 puntos y cables jumper: para el ejemplo del botón contra el error E9 y tus siguientes circuitos.
• Pulsador táctil de 4 patas y resistencias: el botón del ejemplo, y una resistencia de 4,7 kΩ o 8,2 kΩ si necesitas el pull down externo.
• Sensor BME280 o DS18B20: si quieres medir la temperatura real de la pieza para el nodo de Home Assistant.

Si en el tutorial original usan un kit de electrónica con protoboard, LEDs y resistencias de una marca extranjera, cualquier kit de iniciación con protoboard y componentes pasivos del catálogo cumple la misma función.

Recursos

• Tutorial original (alemán): Raspberry Pi Pico 2 W: Einstieg mit MicroPython und Thonny, de Philipp Schweizer en raspberry.tips. Esta versión está basada en él.
• Firmware MicroPython para el Pico 2 W: micropython.org/download/RPI_PICO2_W
• Editor Thonny: thonny.org
• Referencia rápida de MicroPython para RP2: docs.micropython.org/en/latest/rp2/quickref.html
• Documentación oficial del Pico y del RP2350 (hojas de datos, errata, flash_nuke.uf2): raspberrypi.com/documentation/microcontrollers

Versión chilena con componentes en stock local.