Raspberry Pi Pico W y MQTT con MicroPython: publica datos de sensores y recibe comandos

Los proyectos Raspberry Pi Pico W MQTT son un gran primer paso en el hardware conectado: la placa cuesta poco, MicroPython es fácil de leer y MQTT te da una forma ligera de enviar lecturas a la nube y recibir comandos de vuelta. En este tutorial instalarás MicroPython y la librería umqtt.simple, publicarás la temperatura interna de la Pico W en un broker cada diez segundos, encenderás el LED integrado desde tu ordenador y harás que todo sobreviva a las desconexiones del Wi-Fi y del broker.

Qué necesitas

No hace falta ningún sensor adicional. El RP2040 tiene un sensor de temperatura interno en el canal ADC 4, perfecto para validar el recorrido de los datos antes de conectar hardware real. Si todavía estás eligiendo placa, nuestra comparativa ESP32 frente a Raspberry Pi Pico W y la guía Pico W frente a Pico 2 W explican las ventajas y desventajas.

Paso 1: instala MicroPython

1. Descarga el último archivo UF2 de MicroPython para la Raspberry Pi Pico W (nombre de placa RPI_PICO_W) desde la página de descargas de MicroPython o la documentación de MicroPython de Raspberry Pi. La versión para la Pico normal no tiene soporte Wi-Fi, así que asegúrate de elegir la variante W.
2. Mantén pulsado el botón BOOTSEL mientras conectas la placa por USB. Aparecerá como una unidad llamada RPI-RP2.
3. Copia el archivo UF2 en la unidad. La placa se reinicia automáticamente en MicroPython.
4. Abre Thonny, elige MicroPython (Raspberry Pi Pico) como intérprete en la esquina inferior derecha y deberías ver el prompt >>>.

Escribe import network en el prompt. Si funciona sin error, tienes la versión con Wi-Fi.

Paso 2: instala umqtt.simple

MicroPython distribuye umqtt.simple como paquete en micropython-lib en lugar de incluirlo en todas las versiones del firmware. Instálalo cuando la placa tenga acceso a internet, usando mip desde el REPL tras conectarte al Wi-Fi:

import network, time, mip
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("YOUR_WIFI_SSID", "YOUR_WIFI_PASSWORD")
while not wlan.isconnected():
    time.sleep(0.5)
mip.install("umqtt.simple")

Como alternativa, desde tu ordenador con la placa conectada por USB:

pip install mpremote
mpremote mip install umqtt.simple

Thonny también tiene Tools → Manage packages, donde puedes buscar umqtt.simple. Cualquiera de los tres métodos coloca la librería en /lib en la placa.

Paso 3: planifica los topics y el client ID

Todo cliente MQTT necesita un client ID único y no vacío. La Pico W tiene un ID de placa único que podemos usar, así que dos placas con el mismo código nunca chocan. Para los topics usamos un prefijo de demo con una cadena aleatoria de tu elección:

El servidor MQTT público gratuito broker.connectmq.com acepta conexiones anónimas en el puerto 1883, pero todo lo que se publica ahí es visible para cualquiera que se suscriba. Usa un prefijo único y envía solo datos de prueba.

Paso 4: el programa Raspberry Pi Pico W MQTT completo

Guárdalo como main.py en la placa para que se ejecute al arrancar. Cambia las credenciales Wi-Fi y sustituye pw7c3e por tu propia cadena.

# main.py - ejemplo Raspberry Pi Pico W MQTT (MicroPython + umqtt.simple)
import time
import network
import machine
import ubinascii
import rp2
from umqtt.simple import MQTTClient

WIFI_SSID = "YOUR_WIFI_SSID"
WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"
COUNTRY = "GB"                      # tu código de país de dos letras

BROKER = "broker.connectmq.com"
PORT = 1883
PREFIX = "connectmq/demo/pw7c3e/pico1"
CLIENT_ID = "pico-" + ubinascii.hexlify(machine.unique_id()).decode()

PUBLISH_INTERVAL_MS = 10_000
KEEPALIVE_S = 60

led = machine.Pin("LED", machine.Pin.OUT)
sensor = machine.ADC(4)


def read_temperature():
    # Sensor interno del RP2040: 27 C a 0,706 V, pendiente -1,721 mV/C
    voltage = sensor.read_u16() * 3.3 / 65535
    return round(27 - (voltage - 0.706) / 0.001721, 2)


def connect_wifi():
    rp2.country(COUNTRY)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.config(pm=0xA11140)        # desactiva el ahorro de energía para un enlace más ágil
    if not wlan.isconnected():
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        for _ in range(30):
            if wlan.isconnected():
                break
            led.toggle()
            time.sleep(0.5)
    if not wlan.isconnected():
        raise OSError("Wi-Fi connection failed, status %d" % wlan.status())
    print("Wi-Fi connected:", wlan.ifconfig()[0])
    led.off()


def on_message(topic, msg):
    topic = topic.decode()
    msg = msg.decode().strip().upper()
    print("Received", topic, msg)
    if topic == PREFIX + "/led/set":
        if msg in ("ON", "1"):
            led.on()
        elif msg in ("OFF", "0"):
            led.off()
        client.publish(PREFIX + "/led/state", "ON" if led.value() else "OFF", retain=True)


def connect_mqtt():
    c = MQTTClient(CLIENT_ID, BROKER, port=PORT, keepalive=KEEPALIVE_S)
    c.set_last_will(PREFIX + "/status", "offline", retain=True, qos=1)
    c.set_callback(on_message)
    c.connect()
    c.publish(PREFIX + "/status", "online", retain=True, qos=1)
    c.subscribe(PREFIX + "/led/set", qos=1)
    print("MQTT connected as", CLIENT_ID)
    return c


client = None


def main():
    global client
    connect_wifi()
    client = connect_mqtt()
    last_publish = time.ticks_ms() - PUBLISH_INTERVAL_MS
    last_ping = time.ticks_ms()

    while True:
        client.check_msg()                         # gestiona los comandos entrantes
        now = time.ticks_ms()

        if time.ticks_diff(now, last_publish) >= PUBLISH_INTERVAL_MS:
            temp = read_temperature()
            payload = '{"value": %s, "unit": "C"}' % temp
            client.publish(PREFIX + "/temperature", payload)
            print("Published", payload)
            last_publish = now
            last_ping = now

        elif time.ticks_diff(now, last_ping) >= (KEEPALIVE_S // 2) * 1000:
            client.ping()                          # mantiene viva la sesión
            last_ping = now

        time.sleep_ms(100)


while True:
    try:
        main()
    except OSError as e:
        print("Connection problem:", e, "- retrying in 5 s")
        try:
            if client:
                client.disconnect()
        except Exception:
            pass
        time.sleep(5)

Pulsa Run en Thonny o reinicia la placa. La consola debería mostrar la dirección Wi-Fi, la conexión MQTT y una publicación cada diez segundos.

Cómo funciona el programa

• Client ID único. machine.unique_id() se lee del chip flash, así que cada placa obtiene su propio ID automáticamente.
• Last Will. Si la Pico desaparece sin una desconexión limpia, el broker publica offline en el topic de estado en su nombre. Junto con el mensaje online retained, cualquier suscriptor puede ver si el dispositivo está activo.
• Bucle no bloqueante. check_msg() vuelve de inmediato cuando no hay nada que leer, así que el bucle puede publicar según un temporizador y aun así reaccionar a los comandos del LED en una décima de segundo aproximadamente.
• Pings de keepalive. umqtt.simple no envía pings automáticamente. Sin las llamadas a ping(), el broker cerraría una conexión inactiva tras el intervalo de keepalive.
• Reconexión. Cualquier error de socket lanza OSError; el bucle exterior espera cinco segundos y vuelve a empezar, incluido el Wi-Fi si hace falta.

Paso 5: prueba desde tu ordenador

Observa todo lo que publica la Pico:

mosquitto_sub -h broker.connectmq.com -p 1883 -i laptop-pw7c3e -v -t "connectmq/demo/pw7c3e/#"

Enciende y apaga el LED:

mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-pw7c3e -t "connectmq/demo/pw7c3e/pico1/led/set" -m "ON"
mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-pw7c3e -t "connectmq/demo/pw7c3e/pico1/led/set" -m "OFF"

El LED debería obedecer, y el suscriptor muestra el nuevo estado. Desconecta la Pico y, tras el periodo de keepalive, el suscriptor recibe offline desde el Last Will.

Solución de problemas

El sensor integrado también es sensible a la tensión de referencia exacta, así que las lecturas pueden desviarse unos grados. Para este tutorial no importa; para mediciones reales, conecta un DS18B20, un BME280 o un SHT31.

De la demo a producción

El servidor público es compartido y abierto, así que los dispositivos de producción deberían conectarse con sus propias credenciales y TLS. En ConnectMQ, crea un broker en el portal y copia el nombre de usuario, la contraseña y el client ID generados. Los client IDs están vinculados a las credenciales emitidas, así que usa el valor exacto YOUR_CLIENT_ID del portal en lugar del ID derivado de la placa, y pasa user="YOUR_USERNAME" y password="YOUR_PASSWORD" a MQTTClient. Después pasa al puerto 8883 con verificación de certificado, lo que se explica paso a paso en Pico W MQTT sobre TLS. Para diseños alimentados por batería, consulta Pico W con batería y MQTT.

Un broker MQTT gestionado como ConnectMQ también te ofrece herramientas alrededor del dispositivo: el cliente MQTT en el navegador y el explorador de topics en vivo del portal te permiten revisar los topics de la Pico sin instalar nada, y las reglas de alerta por umbral pueden avisarte cuando una temperatura se sale de rango. Para más proyectos con Raspberry Pi, incluidas las placas de tamaño completo, empieza por el tutorial de MQTT con Raspberry Pi.

Conecta tu Pico W a ConnectMQ

Regístrate en app.connectmq.com con el plan gratuito Serverless, sin tarjeta de crédito. Crea un broker, copia las credenciales en main.py y tu Pico W estará hablando con un broker privado en pocos minutos. Las 25 conexiones del plan gratuito alcanzan para toda una estantería de placas Pico W.

Preguntas frecuentes

¿Qué librería MQTT debo usar en la Pico W?

umqtt.simple de micropython-lib es la opción estándar para MicroPython. Es pequeña, admite QoS 0 y 1, Last Will, retained messages y TLS, y se instala con mip.

¿La Raspberry Pi Pico W admite MQTT sobre TLS?

Sí. El módulo ssl de MicroPython funciona en la Pico W, y umqtt.simple puede conectarse al puerto 8883 con verificación de certificado, aunque el handshake tarda bastante más que en chips con aceleración criptográfica.

¿Por qué mi Pico W se desconecta del broker MQTT al cabo de un minuto?

umqtt.simple no envía pings de keepalive por sí solo. Llama a client.ping() con regularidad, al menos una vez por intervalo de keepalive, o publica con la frecuencia suficiente para mantener la conexión activa.

¿Puedo usar la Pico W con Arduino en lugar de MicroPython?

Sí. El core Arduino-Pico admite el Wi-Fi de la Pico W, y librerías como PubSubClient funcionan con él. MicroPython suele ser más rápido para prototipar, mientras que C/C++ da más control sobre la memoria y los tiempos.