Raspberry Pi Pico W et MQTT avec MicroPython : publier des données de capteur et recevoir des commandes

Les projets Raspberry Pi Pico W MQTT sont une excellente première étape dans le matériel connecté : la carte coûte peu, MicroPython se lit facilement, et MQTT offre un moyen léger d'envoyer des mesures vers le cloud et de recevoir des commandes en retour. Dans ce tutoriel, vous allez flasher MicroPython, installer la bibliothèque umqtt.simple, publier la température interne du Pico W vers un broker toutes les dix secondes, commander la LED intégrée depuis votre ordinateur, et faire en sorte que l'ensemble survive aux déconnexions du Wi-Fi et du broker.

Ce dont vous avez besoin

Aucun capteur supplémentaire n'est nécessaire. Le RP2040 intègre un capteur de température sur le canal ADC 4, idéal pour valider la chaîne de données avant de brancher du vrai matériel. Si vous hésitez encore entre plusieurs cartes, notre comparatif ESP32 vs Raspberry Pi Pico W et notre guide Pico W vs Pico 2 W détaillent les compromis.

Étape 1 : flasher MicroPython

1. Téléchargez le dernier fichier UF2 MicroPython pour le Raspberry Pi Pico W (nom de carte RPI_PICO_W) depuis la page de téléchargement de MicroPython ou la documentation MicroPython de Raspberry Pi. La version pour le Pico simple ne gère pas le Wi-Fi : veillez à choisir la variante W.
2. Maintenez le bouton BOOTSEL enfoncé en branchant la carte en USB. Elle apparaît comme un lecteur nommé RPI-RP2.
3. Copiez le fichier UF2 sur ce lecteur. La carte redémarre automatiquement sous MicroPython.
4. Ouvrez Thonny, choisissez MicroPython (Raspberry Pi Pico) comme interpréteur dans le coin inférieur droit : l'invite >>> doit apparaître.

Tapez import network à l'invite. Si aucune erreur ne s'affiche, vous avez bien la version Wi-Fi.

Étape 2 : installer umqtt.simple

MicroPython fournit umqtt.simple sous forme de paquet dans micropython-lib plutôt que dans chaque firmware. Installez-le dès que la carte peut joindre Internet, avec mip depuis le REPL après connexion au 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")

Vous pouvez aussi le faire depuis votre ordinateur, la carte étant branchée en USB :

pip install mpremote
mpremote mip install umqtt.simple

Thonny propose également Outils → Gérer les paquets, où vous pouvez rechercher umqtt.simple. Les trois méthodes placent la bibliothèque dans /lib sur la carte.

Étape 3 : planifier les topics et le client ID

Chaque client MQTT a besoin d'un client ID unique et non vide. Le Pico W possède un identifiant de carte unique que nous pouvons utiliser : deux cartes exécutant le même code n'entrent ainsi jamais en conflit. Pour les topics, nous utilisons un préfixe de démo avec une chaîne aléatoire de votre choix :

Le serveur MQTT public gratuit broker.connectmq.com accepte les connexions anonymes sur le port 1883, mais tout ce qui y est publié est visible par quiconque s'abonne. Utilisez un préfixe unique et n'envoyez que des données de test.

Étape 4 : le programme Raspberry Pi Pico W MQTT complet

Enregistrez ce fichier sous main.py sur la carte pour qu'il s'exécute au démarrage. Modifiez les identifiants Wi-Fi et remplacez pw7c3e par votre propre chaîne.

# main.py - Raspberry Pi Pico W MQTT example (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"                      # votre code pays à deux lettres

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():
    # capteur interne du RP2040 : 27 C à 0,706 V, pente -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)        # désactive l'économie d'énergie pour une liaison réactive
    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()                         # traite les commandes 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()                          # maintient la session active
            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)

Cliquez sur Exécuter dans Thonny, ou réinitialisez la carte. Le shell doit afficher l'adresse Wi-Fi, la connexion MQTT et une publication toutes les dix secondes.

Fonctionnement du programme

• Client ID unique. machine.unique_id() est lu depuis la puce flash : chaque carte obtient automatiquement son propre identifiant.
• Last Will. Si le Pico disparaît sans déconnexion propre, le broker publie offline sur le topic de statut à sa place. Combiné au message online retained, n'importe quel abonné peut savoir si l'appareil est actif.
• Boucle non bloquante. check_msg() rend la main immédiatement lorsqu'il n'y a rien à lire : la boucle peut donc publier selon une minuterie tout en réagissant aux commandes de la LED en un dixième de seconde environ.
• Pings keepalive. umqtt.simple n'envoie pas de ping automatiquement. Sans les appels à ping(), le broker fermerait une connexion silencieuse à l'expiration de l'intervalle keepalive.
• Reconnexion. Toute erreur de socket lève une OSError ; la boucle externe attend cinq secondes et recommence, y compris la connexion Wi-Fi si nécessaire.

Étape 5 : tester depuis votre ordinateur

Observez tout ce que publie le Pico :

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

Commandez la 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"

La LED doit suivre, et l'abonné affiche le nouvel état. Débranchez le Pico : après la période keepalive, l'abonné reçoit offline grâce au Last Will.

Dépannage

Le capteur interne est aussi sensible à la tension de référence exacte : les mesures peuvent être décalées de quelques degrés. C'est sans importance pour ce tutoriel ; pour de vraies mesures, branchez un DS18B20, un BME280 ou un SHT31.

De la démo à la production

Le serveur public est partagé et ouvert : les appareils de production doivent se connecter avec leurs propres identifiants et en TLS. Sur ConnectMQ, créez un broker dans le portail et copiez le nom d'utilisateur, le mot de passe et le client ID générés. Les client ID sont liés aux identifiants émis : utilisez donc la valeur exacte YOUR_CLIENT_ID fournie par le portail au lieu de l'identifiant dérivé de la carte, et passez user="YOUR_USERNAME" et password="YOUR_PASSWORD" à MQTTClient. Passez ensuite au port 8883 avec vérification du certificat, ce qui est détaillé pas à pas dans MQTT sur TLS avec le Pico W. Pour les montages sur batterie, consultez Pico W sur batterie avec MQTT.

Un broker MQTT managé comme ConnectMQ vous apporte aussi des outils autour de l'appareil : le client MQTT intégré au navigateur et l'explorateur de topics en direct du portail permettent de vérifier les topics du Pico sans rien installer, et des règles d'alerte à seuil peuvent signaler une température hors plage. Pour d'autres projets Raspberry Pi, y compris sur les cartes de taille standard, commencez par le tutoriel MQTT sur Raspberry Pi.

Connecter votre Pico W à ConnectMQ

Inscrivez-vous sur app.connectmq.com pour l'offre gratuite Serverless (Free), sans carte bancaire. Créez un broker, copiez les identifiants dans main.py, et votre Pico W dialogue avec un broker privé en quelques minutes. Les 25 connexions de l'offre gratuite suffisent pour toute une étagère de cartes Pico W.

Questions fréquentes

Quelle bibliothèque MQTT utiliser sur le Pico W ?

umqtt.simple, issue de micropython-lib, est le choix standard pour MicroPython. Elle est légère, prend en charge la QoS 0 et 1, le Last Will, les retained messages et TLS, et s'installe avec mip.

Le Raspberry Pi Pico W prend-il en charge MQTT sur TLS ?

Oui. Le module ssl de MicroPython fonctionne sur le Pico W, et umqtt.simple peut se connecter au port 8883 avec vérification du certificat, même si la poignée de main est nettement plus longue que sur les puces dotées d'une accélération cryptographique.

Pourquoi mon Pico W se déconnecte-t-il du broker MQTT au bout d'une minute ?

umqtt.simple n'envoie pas de lui-même de pings keepalive. Appelez régulièrement client.ping(), au moins une fois par intervalle keepalive, ou publiez assez souvent pour maintenir la connexion active.

Puis-je utiliser le Pico W avec Arduino plutôt qu'avec MicroPython ?

Oui. Le core Arduino-Pico prend en charge le Wi-Fi du Pico W, et des bibliothèques comme PubSubClient fonctionnent avec lui. MicroPython est généralement plus rapide pour prototyper, tandis que le C/C++ offre plus de contrôle sur la mémoire et le timing.