Raspberry Pi Pico W MQTT: sensor y LED con MicroPython umqtt
¿Cómo usar MQTT con la Raspberry Pi Pico W? Instala umqtt en MicroPython, usa un broker gratis, publica la temperatura, controla un LED y conéctala a Home Assistant.
MQTT con la Raspberry Pi Pico W es la forma más ligera y habitual de conectar tu placa a internet, enviar datos de sensores y recibir órdenes a distancia. Con la librería umqtt.simple de MicroPython, la Pico W se conecta a un broker MQTT con unas pocas líneas, publica la temperatura en un tema (topic) y, suscrita a otro tema, enciende y apaga un LED con mensajes "ON" u "OFF". No necesitas montar un servidor web, abrir puertos en el router ni memorizar la IP de la placa: el móvil, el ordenador y Home Assistant hablan con tu placa a través del mismo broker.
En esta guía primero aprenderás la lógica y los conceptos básicos de MQTT. Después instalarás la librería umqtt, te conectarás a un broker público gratuito, publicarás cada diez segundos la lectura del sensor de temperatura interno de la Pico W y controlarás el LED integrado de forma remota. Por último, harás que el código se recupere solo cuando falle el Wi-Fi o el broker, y añadirás la placa a Home Assistant con MQTT Discovery sin escribir una sola línea de YAML.

¿Qué es MQTT y cómo funciona?
MQTT (Message Queuing Telemetry Transport) es un protocolo de mensajería de tipo publicación/suscripción (publish/subscribe) pensado para dispositivos con poco ancho de banda y poca potencia de cálculo. En el centro del sistema hay un servidor llamado broker. Los dispositivos no se conectan entre sí directamente: cada uno abre una conexión TCP con el broker (puerto 1883 sin cifrar, 8883 con TLS). Cuando un dispositivo publica un mensaje en un tema como "bluegrays/picow/temperatura", el broker lo reenvía a todos los suscritos a ese tema. Así, la Pico W no necesita saber quién leerá el mensaje: una app del móvil, un registrador de datos y Home Assistant pueden recibir el mismo dato a la vez. La cabecera fija de un paquete MQTT ocupa solo 2 bytes, por lo que gasta mucho menos datos y energía que las peticiones HTTP.
| Concepto | Significado | Ejemplo |
|---|---|---|
| Broker | Servidor que recibe los mensajes y los distribuye a los suscriptores | Mosquitto, HiveMQ, EMQX |
| Client (cliente) | Cualquier dispositivo o aplicación que se conecta al broker | Pico W, móvil, Home Assistant |
| Topic (tema) | Dirección del mensaje, separada por / | bluegrays/picow/temperatura |
| Publish (publicar) | Enviar un mensaje a un tema | Enviar el valor "23.4" |
| Subscribe (suscribirse) | Escuchar los mensajes que llegan a un tema | bluegrays/picow/led |
| QoS | Garantía de entrega: 0 como máximo una vez, 1 al menos una vez, 2 exactamente una vez | umqtt.simple admite 0 y 1 |
| Retain | El broker guarda el último mensaje y lo envía enseguida a quien se suscriba | Último estado del LED |
| Last Will (LWT) | Mensaje que el broker publica si el dispositivo se desconecta de forma inesperada | "offline" |
| Keepalive | Cada cuántos segundos, como máximo, debe enviar un paquete el cliente | 60 |
Los temas funcionan como la ruta de una carpeta y distinguen mayúsculas de minúsculas. Al suscribirte puedes usar dos comodines: + sustituye un solo nivel ("casa/+/temperatura" captura tanto "casa/salon/temperatura" como "casa/cocina/temperatura") y # abarca todos los niveles restantes y solo se usa al final ("casa/#"). Al publicar no se pueden usar comodines. Evitar espacios y caracteres especiales en los nombres de los temas reduce la probabilidad de problemas entre distintos clientes.
Material necesario y conexiones de la Pico W
- Raspberry Pi Pico W o Pico 2 W: con una Pico normal, sin chip inalámbrico, no se puede usar MQTT.
- Firmware de MicroPython: el archivo .uf2 preparado para la versión W. Los pasos de instalación están en el artículo ¿Qué es la Raspberry Pi Pico?.
- Thonny u otro editor de MicroPython y un cable micro USB que transmita datos.
- Red Wi-Fi de 2,4 GHz: la Pico W no puede conectarse a redes de 5 GHz.
- Un cliente MQTT: para probar, MQTT Explorer en el ordenador o una app de panel MQTT en el móvil.
- Opcional: un LED externo con una resistencia de 220 Ω, un sensor externo como DHT22 o BME280 y un módulo de relé.
| Componente | Conexión a la Pico W | Nota |
|---|---|---|
| LED integrado | Pin("LED") | Se controla a través del chip inalámbrico, no es GP25 |
| Sensor de temperatura interno | ADC(4) | No necesita cables; mide la temperatura del propio chip |
| LED externo | GP15 → 220 Ω → ánodo del LED, cátodo → GND | En el código Pin(15, Pin.OUT) |
| Pin de datos del DHT22 | GP16 (VCC → 3V3, GND → GND) | Se lee con el módulo dht de MicroPython |
| IN del módulo de relé | GP14 | Elige un módulo que se active con 3,3 V |
| Pines reservados al chip inalámbrico | GPIO23, 24, 25, 29 | No salen de la placa y no se pueden usar para otra cosa |
Instalar la librería umqtt
- Conecta la placa al ordenador manteniendo pulsado el botón BOOTSEL y copia el archivo .uf2 de MicroPython específico para la versión W en la unidad RPI-RP2 que aparece.
- En Thonny, elige abajo a la derecha el intérprete MicroPython (Raspberry Pi Pico) y escribe en la consola from umqtt.simple import MQTTClient. Si no da error, la librería ya viene en el firmware y no hace falta instalar nada.
- Si aparece un ImportError, conecta la placa a tu red Wi-Fi con el código de abajo y descarga la librería directamente de internet con mip.
- Como alternativa, en Thonny ve a Herramientas > Administrar paquetes, busca micropython-umqtt.simple e instálalo.
- Tras la instalación deberías ver el archivo /lib/umqtt/simple.py en el sistema de archivos de la Pico.
1import network
2import time
3import mip
4
5wlan = network.WLAN(network.STA_IF)
6wlan.active(True)
7wlan.connect("WIFI_ADIN", "WIFI_SIFREN") # kendi ağ bilgilerin / your network credentials
8
9while not wlan.isconnected():
10 print("Baglaniyor... / Connecting...")
11 time.sleep(1)
12
13print("IP:", wlan.ifconfig()[0])
14mip.install("umqtt.simple") # /lib/umqtt/simple.py olarak kurulur / installed as /lib/umqtt/simple.py
15mip.install("umqtt.robust") # isteğe bağlı / optionalElegir un broker MQTT gratuito
Para empezar no necesitas montar tu propio servidor. Muchas empresas mantienen brokers públicos para pruebas; no piden usuario ni contraseña, y en pocos minutos puedes conectar la placa y enviar tu primer mensaje. Para un proyecto permanente, lo más sólido es instalar Mosquitto en una Raspberry Pi doméstica, en un ordenador viejo o en Home Assistant: los datos se quedan en tu casa y, aunque se caiga internet, los dispositivos de la red local siguen intercambiando mensajes.
| Broker | Dirección | Puerto | Nota |
|---|---|---|---|
| Broker público de HiveMQ | broker.hivemq.com | 1883 (TCP) | Sin registro, abierto a todos |
| Servidor de pruebas Eclipse Mosquitto | test.mosquitto.org | 1883 (sin cifrar), 8883 (TLS) | Sin registro, abierto a todos |
| Broker público de EMQX | broker.emqx.io | 1883 (TCP), 8883 (TLS) | Sin registro, abierto a todos |
| Complemento Mosquitto de Home Assistant | IP local de Home Assistant | 1883 | Requiere usuario y contraseña |
| Tu propio servidor Mosquitto | IP de tu Raspberry Pi u ordenador | 1883 | Control total, funciona en la red local |
Paso a paso: publicar la temperatura y suscribirse al LED
El siguiente programa hace cuatro cosas a la vez: se conecta a la red Wi-Fi, se conecta al broker con un ID de cliente único, se suscribe al tema bluegrays/picow/led y publica cada diez segundos el valor del sensor de temperatura interno en el tema bluegrays/picow/sicaklik. Si al tema del LED llega "ON", el LED se enciende; si llega "OFF", se apaga, y el nuevo estado se comunica en otro tema con la bandera retain. Si guardas el archivo en la Pico con el nombre main.py desde Thonny, el programa arrancará solo cada vez que se encienda la placa.
1import network
2import time
3import machine
4import binascii
5from machine import Pin, ADC
6from umqtt.simple import MQTTClient
7
8SSID = "WIFI_ADIN" # Wi-Fi ağ adın / your Wi-Fi name
9PASSWORD = "WIFI_SIFREN" # Wi-Fi şifren / your Wi-Fi password
10BROKER = "broker.hivemq.com" # ücretsiz genel broker / free public broker
11PORT = 1883
12MQTT_USER = None # Home Assistant için kullanıcı / user for Home Assistant
13MQTT_PASS = None # Home Assistant için şifre / password for Home Assistant
14
15CLIENT_ID = b"picow-" + binascii.hexlify(machine.unique_id()) # benzersiz kimlik / unique client id
16TOPIC_TEMP = b"bluegrays/picow/sicaklik"
17TOPIC_LED = b"bluegrays/picow/led"
18TOPIC_LED_STATE = b"bluegrays/picow/led/durum"
19TOPIC_STATUS = b"bluegrays/picow/durum"
20PUBLISH_MS = 10000 # 10 saniyede bir yayınla / publish every 10 s
21
22led = Pin("LED", Pin.OUT) # Pico W dahili LED / Pico W onboard LED
23sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
24wlan = network.WLAN(network.STA_IF)
25client = None
26pending_state = None # bildirilecek LED durumu / LED state to report
27
28
29def read_temp():
30 voltage = sensor.read_u16() * 3.3 / 65535
31 return 27 - (voltage - 0.706) / 0.001721
32
33
34def wifi_connect():
35 wlan.active(True)
36 if wlan.isconnected():
37 return
38 wlan.connect(SSID, PASSWORD)
39 for _ in range(20): # en fazla 20 saniye bekle / wait up to 20 s
40 if wlan.isconnected():
41 print("IP:", wlan.ifconfig()[0])
42 return
43 time.sleep(1)
44 raise OSError("Wi-Fi baglanamadi / Wi-Fi failed")
45
46
47def on_message(topic, msg):
48 global pending_state
49 print("Mesaj / Message:", topic, msg)
50 if topic == TOPIC_LED:
51 if msg == b"ON":
52 led.on()
53 pending_state = b"ON"
54 elif msg == b"OFF":
55 led.off()
56 pending_state = b"OFF"
57
58
59def mqtt_connect():
60 c = MQTTClient(CLIENT_ID, BROKER, port=PORT, user=MQTT_USER,
61 password=MQTT_PASS, keepalive=60)
62 c.set_callback(on_message)
63 c.set_last_will(TOPIC_STATUS, b"offline", retain=True) # koparsa broker yayınlar / broker sends it on drop
64 try:
65 c.connect()
66 except Exception:
67 try:
68 c.sock.close() # yarım kalan soketi kapat / close the half-open socket
69 except Exception:
70 pass
71 raise
72 c.subscribe(TOPIC_LED)
73 c.publish(TOPIC_STATUS, b"online", retain=True)
74 return c
75
76
77def reconnect():
78 global client
79 delay = 2
80 while True:
81 if client:
82 try:
83 client.sock.close()
84 except Exception:
85 pass
86 try:
87 wifi_connect()
88 client = mqtt_connect()
89 print("MQTT bagli / connected")
90 return
91 except Exception as e:
92 print("Tekrar denenecek / retrying:", e)
93 time.sleep(delay)
94 delay = min(delay * 2, 60) # üstel bekleme / exponential backoff
95
96
97reconnect()
98last_pub = time.ticks_add(time.ticks_ms(), -PUBLISH_MS) # ilk yayın hemen / first publish right away
99
100while True:
101 try:
102 client.check_msg() # gelen mesaj var mı? / any incoming message?
103 if pending_state:
104 client.publish(TOPIC_LED_STATE, pending_state, retain=True)
105 pending_state = None
106 if time.ticks_diff(time.ticks_ms(), last_pub) >= PUBLISH_MS:
107 last_pub = time.ticks_ms()
108 temp = "{:.1f}".format(read_temp())
109 client.publish(TOPIC_TEMP, temp.encode())
110 print("Yayinlandi / Published:", temp)
111 except Exception as e:
112 print("Baglanti koptu / Connection lost:", e)
113 reconnect()
114 time.sleep_ms(100)| Fragmento de código | ¿Qué hace? |
|---|---|
| CLIENT_ID | Genera con machine.unique_id() un ID propio para cada placa; dos dispositivos que se conectan con el mismo ID se expulsan mutuamente del broker |
| read_temp() | Convierte el valor de ADC(4) a voltaje y el voltaje a grados Celsius con la fórmula 27 - (V - 0,706) / 0,001721 |
| set_last_will() | Hace que el broker escriba "offline" en el tema de estado si la conexión se pierde de forma inesperada; debe ejecutarse antes de llamar a connect() |
| subscribe() | Empieza a escuchar el tema del LED; se vuelve a llamar en cada conexión nueva |
| check_msg() | Si hay un mensaje entrante, llama a la función on_message; si no, vuelve sin esperar |
| pending_state | En lugar de publicar dentro del callback, deja el estado en una variable y la publicación la hace el bucle principal |
| ticks_diff() | Mide los diez segundos sin bloquear con sleep, así los comandos del LED se procesan sin retraso |
| reconnect() | Reintenta la conexión Wi-Fi y MQTT con intervalos de 2, 4, 8 … hasta un máximo de 60 segundos |
Tras ejecutar el programa, conéctate al mismo broker con MQTT Explorer en tu ordenador y suscríbete al tema bluegrays/picow/#. Deberías ver llegar el valor de la temperatura cada diez segundos y "online" en el tema de estado. Para probar el LED, publica ON en mayúsculas en el tema bluegrays/picow/led: el LED verde de la placa se enciende de inmediato y el mensaje recibido se imprime en la consola de Thonny. Si tienes instaladas las herramientas cliente de Mosquitto, puedes hacer lo mismo desde la línea de comandos con mosquitto_pub -h broker.hivemq.com -t bluegrays/picow/led -m ON. Como el sensor interno mide la temperatura del propio chip, puede marcar unos grados más o menos que la de la habitación; para medir el ambiente real, conecta un sensor externo como el DHT11/DHT22 o el BME280 y modifica la función read_temp() en consecuencia.
Reconectar automáticamente cuando se pierde la conexión
El mayor enemigo de un dispositivo IoT doméstico son las caídas de conexión: el router se reinicia, la señal Wi-Fi se debilita o el broker entra en mantenimiento. umqtt.simple no se recupera por sí solo en estos casos; en la siguiente llamada a publish() o check_msg() lanza un OSError. El bloque try/except del programa captura ese error y llama a la función reconnect(). Esta primero cierra el socket viejo, vuelve a conectar el Wi-Fi si se había caído y luego recrea desde cero la conexión MQTT y la suscripción. Tras cada intento fallido el tiempo de espera se duplica (2, 4, 8, 16, 32, 60 segundos); esto se llama retroceso exponencial y evita que saturies el broker con decenas de intentos por segundo.
El valor de keepalive también es importante. En el código usamos 60 segundos; según las reglas de MQTT, el broker cierra la conexión si no recibe ningún paquete del cliente durante 1,5 veces ese tiempo (es decir, 90 segundos). Como publicamos cada diez segundos, no hay problema. Pero si alargas el intervalo de publicación a, por ejemplo, cinco minutos, tendrás que añadir llamadas periódicas a client.ping(); umqtt.simple no envía el paquete de ping automáticamente. Gracias al mensaje Last Will, aunque desenchufes la placa, el broker escribirá "offline" en el tema de estado cuando venza el keepalive y Home Assistant mostrará el dispositivo como "no disponible".
- Guarda los datos del Wi-Fi y la contraseña del broker en un archivo secrets.py aparte; no compartas ese archivo cuando compartas el código.
- Para mayor estabilidad, activa un temporizador watchdog con machine.WDT(timeout=8000) y llama regularmente a wdt.feed() en el bucle principal; si el programa se queda colgado, la placa se reinicia sola. En ese caso mantén las esperas dentro de reconnect() por debajo de 8 segundos o alimenta el watchdog mientras esperas.
- Publica la medición a intervalos y no en cada vuelta del bucle; para reducir las fluctuaciones instantáneas, haz la media de varias lecturas (filtrado de datos de sensores).
- Usa retain en temas cuyo último valor importa, como el estado del LED; no envíes mensajes con retain a los temas de comandos, o la placa volverá a aplicar el comando antiguo cada vez que se reconecte.
- Si la conexión se cae con frecuencia, prueba a desactivar el modo de ahorro de energía del chip inalámbrico con wlan.config(pm=0xa11140); reduce la latencia pero aumenta el consumo de corriente.
Conectar la Pico W a Home Assistant
- En Home Assistant, instala e inicia el complemento Mosquitto broker desde Ajustes > Complementos.
- En Ajustes > Personas crea un usuario independiente para la Pico W (por ejemplo "pico"); la conexión MQTT usará el nombre y la contraseña de ese usuario.
- En Ajustes > Dispositivos y servicios, configura la integración MQTT que se haya descubierto.
- Cambia el valor de BROKER en el código por la IP local de Home Assistant (por ejemplo 192.168.1.50) y escribe el usuario y la contraseña en las variables MQTT_USER y MQTT_PASS.
- Añade al código la función ha_discovery() de abajo y llámala como ha_discovery(c) en mqtt_connect(), justo después de la línea subscribe().
- En unos segundos aparecerá en la lista de dispositivos uno nuevo llamado "Pico W", con el sensor de temperatura y el interruptor del LED.
1import json
2import binascii
3import machine
4
5DEVICE_ID = "picow_" + binascii.hexlify(machine.unique_id()).decode()
6DEVICE = {
7 "identifiers": [DEVICE_ID],
8 "name": "Pico W",
9 "manufacturer": "Raspberry Pi",
10 "model": "Pico W",
11}
12
13
14def ha_discovery(c):
15 temp_cfg = {
16 "name": "Sicaklik",
17 "unique_id": DEVICE_ID + "_temp",
18 "state_topic": "bluegrays/picow/sicaklik",
19 "unit_of_measurement": "°C",
20 "device_class": "temperature",
21 "availability_topic": "bluegrays/picow/durum",
22 "device": DEVICE,
23 }
24 led_cfg = {
25 "name": "LED",
26 "unique_id": DEVICE_ID + "_led",
27 "command_topic": "bluegrays/picow/led",
28 "state_topic": "bluegrays/picow/led/durum",
29 "payload_on": "ON",
30 "payload_off": "OFF",
31 "availability_topic": "bluegrays/picow/durum",
32 "device": DEVICE,
33 }
34 base = DEVICE_ID.encode()
35 # JSON'u bytes olarak gönder (°C çok baytlıdır) / send JSON as bytes (°C is multi-byte)
36 c.publish(b"homeassistant/sensor/" + base + b"/temp/config",
37 json.dumps(temp_cfg).encode(), retain=True)
38 c.publish(b"homeassistant/switch/" + base + b"/led/config",
39 json.dumps(led_cfg).encode(), retain=True)
40
41# mqtt_connect() içinde subscribe() satırından sonra çağır / call after subscribe() in mqtt_connect()
42# ha_discovery(c)Home Assistant escucha por defecto los temas que empiezan por homeassistant/. Cuando la Pico W envía a esos temas una configuración JSON con la bandera retain, Home Assistant crea las entidades automáticamente: la configuración del sensor muestra la temperatura como un valor que se puede graficar y la del switch añade a la interfaz un interruptor de encendido/apagado. Al pulsar el interruptor, Home Assistant publica "ON" u "OFF" en command_topic, la placa cambia el LED y escribe el nuevo estado en state_topic; así el interruptor de la interfaz siempre refleja el estado real. El campo availability_topic usa el mensaje Last Will para mostrar las entidades en gris cuando la placa se apaga. Si quieres ver la misma estructura con una ESP32, echa un vistazo a ESP32 con MQTT y Home Assistant.
Ideas de proyectos con Pico W y MQTT
- Panel de temperatura y humedad por habitación: pon una Pico W y un DHT22 en cada habitación y controla toda la casa en una sola pantalla con temas como casa/salon/temperatura.
- Lámpara con control remoto: en lugar de un LED, controla un módulo de relé y enciende y apaga la lámpara desde Home Assistant.
- Aviso de riego de plantas: publica el valor de un sensor de humedad del suelo y envía una notificación al móvil mediante una automatización cuando la tierra se seque.
- Alarma de movimiento: publica un mensaje en el tema casa/pasillo/movimiento cuando se active un sensor PIR.
- Termómetro de acuario: mide la temperatura del agua con un DS18B20 y envía un mensaje de aviso con retain cuando se supere el umbral.
- Compáralo con una interfaz web: controla el mismo LED también con un servidor web en la Pico W y comprueba la diferencia entre ambos métodos.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| ImportError: no module named 'umqtt' | La librería no está en el firmware | mip.install("umqtt.simple") o el gestor de paquetes de Thonny |
| El Wi-Fi no se conecta de ninguna manera | Red de 5 GHz, contraseña incorrecta o señal débil | Usa una red de 2,4 GHz, imprime el valor de wlan.status() y acerca la placa al router |
| OSError durante connect() | No se pudo resolver la dirección del broker o no hay red | Comprueba antes wlan.isconnected() y escribe bien el nombre del broker y el puerto |
| MQTTException: 4 o 5 | Usuario o contraseña incorrectos, sin autorización | Revisa el usuario y la contraseña de Home Assistant |
| La conexión se corta a los 90 segundos aproximadamente | No se envía ningún paquete durante el keepalive | Publica con regularidad o añade client.ping() |
| Los mensajes no llegan nunca | check_msg() no se llama en el bucle o se olvidó set_callback() | Llama a set_callback() antes de subscribe() y usa check_msg() en el bucle |
| La comparación siempre da falso | El tema y el mensaje llegan como bytes y los comparas con str | Usa constantes de bytes como b"ON" |
| Dos placas se expulsan continuamente | Se usa el mismo CLIENT_ID | Genera un ID único con machine.unique_id() |
Una vez montado MQTT, cada nuevo sensor o salida que añadas a la placa es simplemente un tema más; la infraestructura sigue siendo la misma. Primero ejecuta el programa de esta guía con el LED integrado y el sensor de temperatura, y luego amplíalo con relés y sensores externos. Si quieres afianzar los pasos básicos de MicroPython, como LED, botón y PWM, en los proyectos de Raspberry Pi Pico de la app BlueGrays encontrarás el esquema del circuito y el código de cada paso.
Preguntas frecuentes
¿Se puede usar MQTT con una Raspberry Pi Pico normal?
No. La Pico normal no tiene Wi-Fi ni Ethernet, así que no puede conectarse directamente a un broker. Para MQTT necesitas la Pico W o la Pico 2 W, con chip inalámbrico. La Pico normal solo podría salir a la red con un módulo Wi-Fi o Ethernet externo, lo que complica bastante el montaje.
¿Cuál es la diferencia entre umqtt.simple y umqtt.robust?
umqtt.simple es un cliente muy pequeño que hace las operaciones básicas de MQTT (conectar, publicar y suscribirse) y lanza un error cuando se pierde la conexión. umqtt.robust se basa en él e intenta reconectarse automáticamente ante un error. Pero como no renueva las suscripciones por sí solo, tras reconectar tienes que volver a llamar tú a subscribe().
¿Cuál es el mejor broker MQTT gratuito?
Para probar, broker.hivemq.com, test.mosquitto.org y broker.emqx.io son brokers públicos que no requieren registro y funcionan en el puerto 1883. Como son abiertos a todos, solo debes enviarles datos de prueba. Para una instalación permanente y segura, la mejor opción gratuita es instalar Mosquitto en una Raspberry Pi doméstica o en Home Assistant.
¿Cómo se añade la Pico W a Home Assistant?
Instala en Home Assistant el complemento Mosquitto broker y la integración MQTT, y crea un usuario independiente para la Pico W. Conecta la placa con ese usuario a la IP de Home Assistant y publica una configuración de discovery con retain en los temas que empiezan por homeassistant/. Home Assistant creará el sensor y el interruptor automáticamente.
¿Por qué se corta la conexión MQTT de la Pico W?
La causa más habitual es no enviar ningún paquete durante el tiempo de keepalive; umqtt.simple no manda el ping automáticamente, así que hace falta client.ping() o una publicación regular. También provocan cortes una señal Wi-Fi débil, el reinicio del router y un segundo dispositivo con el mismo ID de cliente. Escribir el código para capturar los OSError y reconectar soluciona todos estos casos.
¿Se puede usar TLS (8883) con MQTT en la Pico W?
Sí. Con el parámetro ssl de la librería umqtt.simple puedes establecer una conexión cifrada en el puerto 8883; en las versiones actuales de MicroPython, a este parámetro se le pasa un contexto creado con ssl.SSLContext. El handshake TLS puede tardar unos segundos en la RP2040 y aumenta el uso de RAM. Los brokers en la nube como HiveMQ Cloud suelen exigir conexión TLS.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W)
¡El proyecto de apertura de la serie Raspberry Pi Pico! Hacemos parpadear el LED verde integrado de la Pico para comprobar que la placa funciona: el clásico primer experimento tipo "Hello World". No hacen falta componentes externos, solo la Pico y un cable USB. El código está escrito en MicroPython, el lenguaje con soporte oficial de la Raspberry Pi Foundation.

Encendido de un LED externo con la Raspberry Pi Pico (placa de pruebas)
El siguiente paso tras el LED integrado de la Pico: conectar un LED externo en la protoboard y controlarlo con el pin GP14. Aprenderás a usar cualquier pin GPIO de la Pico como salida, la polaridad del LED (pata larga = ánodo/+, pata corta = cátodo/–) y por qué es imprescindible una resistencia limitadora de corriente (220Ω). Sin ella, pasa demasiada corriente por el LED y puede quemarse.

Raspberry Pi Pico LED Controlado por Botón (Push)
¡Primer proyecto de entrada con Pico — lectura de botón! LED se enciende mientras el botón está presionado. Aprende Pin.IN, Pin.PULL_UP y button.value(). GP14 LED, GP2 botón con PULL_UP interno. Presionado = 0, liberado = 1 — estándar.

Raspberry Pi Pico Botón Toggle LED
¡Botón + LED — siguiente nivel! A diferencia del proyecto básico de botón, no necesitas mantener el botón presionado. Presiona y suelta → LED encendido. Presiona de nuevo → LED apagado (toggle). Mismo circuito, gran diferencia de código. Aprende edge detection, state tracking y debounce.

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.

Raspberry Pi Pico LED RGB Ciclo de Colores (PWM de 3 Canales)
¡Un LED, millones de colores! Un LED RGB contiene 3 LEDs: rojo, verde y azul. Con un canal PWM del Pico para cada uno, los colores se mezclan: rojo + verde = amarillo, verde + azul = cian, los tres = blanco. El LED recorre 8 colores. Aprende múltiples canales PWM, funciones (def), mezcla RGB, conversión de 8 a 16 bits (x257) y cátodo común vs ánodo común.

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

