Raspberry Pi Pico W MQTT : capteur et LED avec umqtt
Comment utiliser MQTT avec le Raspberry Pi Pico W ? Installation d'umqtt en MicroPython, broker gratuit, publication de température, LED à distance et Home Assistant.
MQTT avec le Raspberry Pi Pico W est la façon la plus légère et la plus répandue de connecter ta carte à Internet, d'envoyer des données de capteur et de recevoir des commandes à distance. Avec la bibliothèque MicroPython umqtt.simple, la Pico W se connecte à un broker MQTT en quelques lignes, publie la température mesurée sur un topic et, en s'abonnant à un autre topic, allume ou éteint la LED selon les messages "ON" ou "OFF" reçus. Pas besoin de monter un serveur web, d'ouvrir un port sur la box ou de retenir l'adresse IP de la carte : ton téléphone, ton ordinateur et Home Assistant dialoguent avec elle via le même broker.
Dans ce guide, tu vas d'abord comprendre la logique et les notions de base de MQTT. Ensuite, tu installeras la bibliothèque umqtt, tu te connecteras à un broker public gratuit, tu publieras toutes les dix secondes la valeur du capteur de température interne de la Pico W et tu piloteras la LED intégrée à distance. Enfin, tu rendras le code capable de se rétablir seul quand la connexion Wi-Fi ou le broker tombe, et tu ajouteras la carte à Home Assistant avec MQTT Discovery, sans écrire une seule ligne de YAML.

Qu'est-ce que MQTT et comment ça marche ?
MQTT (Message Queuing Telemetry Transport) est un protocole de messagerie publication/abonnement (publish/subscribe) conçu pour les appareils à faible bande passante et à puissance de calcul limitée. Au centre du système se trouve un serveur appelé broker. Les appareils ne se connectent pas directement entre eux : chacun ouvre une connexion TCP vers le broker (port 1883 sans chiffrement, 8883 avec TLS). Quand un appareil publie un message sur un topic comme "bluegrays/picow/sicaklik", le broker le transmet à tous ceux qui sont abonnés à ce topic. La Pico W n'a donc pas à savoir qui lira le message : une application mobile, un enregistreur de données et Home Assistant peuvent recevoir la même donnée en même temps. L'en-tête fixe d'un paquet MQTT ne fait que 2 octets ; il consomme donc bien moins de données et d'énergie qu'une requête HTTP.
| Notion | Signification | Exemple |
|---|---|---|
| Broker | Serveur qui reçoit les messages et les distribue aux abonnés | Mosquitto, HiveMQ, EMQX |
| Client | Tout appareil ou application connecté au broker | Pico W, téléphone, Home Assistant |
| Topic | Adresse du message, séparée par des / | bluegrays/picow/sicaklik |
| Publish (publier) | Envoyer un message sur un topic | Envoyer la valeur "23.4" |
| Subscribe (s'abonner) | Écouter les messages d'un topic | bluegrays/picow/led |
| QoS | Garantie de livraison : 0 au plus une fois, 1 au moins une fois, 2 exactement une fois | umqtt.simple gère 0 et 1 |
| Retain | Le broker garde le dernier message et l'envoie aussitôt à tout nouvel abonné | Dernier état de la LED |
| Last Will (LWT) | Message que le broker publie si l'appareil se déconnecte brutalement | "offline" |
| Keepalive | Délai maximal en secondes entre deux paquets du client | 60 |
Les topics fonctionnent comme un chemin de dossiers et sont sensibles à la casse. À l'abonnement, tu peux utiliser deux jokers : + remplace un seul niveau ("maison/+/temperature" capte aussi bien "maison/salon/temperature" que "maison/cuisine/temperature"), tandis que # couvre tous les niveaux restants et ne s'utilise qu'à la fin ("maison/#"). Les jokers sont interdits pour publier. Évite les espaces et les caractères accentués dans les noms de topics pour limiter les problèmes entre différents clients.
Matériel nécessaire et branchements de la Pico W
- Raspberry Pi Pico W ou Pico 2 W : impossible d'utiliser MQTT avec une Pico classique sans puce sans fil.
- Firmware MicroPython : le fichier .uf2 préparé pour la version W. L'installation est expliquée dans Qu'est-ce que le Raspberry Pi Pico ?.
- Thonny ou un autre éditeur MicroPython, et un câble micro USB qui transmet les données.
- Un réseau Wi-Fi 2,4 GHz : la Pico W ne se connecte pas aux réseaux 5 GHz.
- Un client MQTT : MQTT Explorer sur l'ordinateur ou une application de panneau MQTT sur le téléphone pour tester.
- En option : une LED externe et une résistance de 220 Ω, un capteur externe comme un DHT22 ou un BME280, un module relais.
| Composant | Connexion à la Pico W | Remarque |
|---|---|---|
| LED intégrée | Pin("LED") | Pilotée via la puce sans fil, ce n'est pas GP25 |
| Capteur de température interne | ADC(4) | Aucun câble ; il mesure la température de la puce elle-même |
| LED externe | GP15 → 220 Ω → anode de la LED, cathode → GND | Dans le code : Pin(15, Pin.OUT) |
| Broche de données du DHT22 | GP16 (VCC → 3V3, GND → GND) | Lu avec le module dht de MicroPython |
| Entrée IN du module relais | GP14 | Choisis un module déclenchable en 3,3 V |
| Broches réservées à la puce sans fil | GPIO23, 24, 25, 29 | Non accessibles, inutilisables pour autre chose |
Installer la bibliothèque umqtt
- Branche la carte à l'ordinateur en maintenant le bouton BOOTSEL et copie le fichier .uf2 MicroPython spécifique à la version W sur le lecteur RPI-RP2 qui apparaît.
- Dans Thonny, choisis en bas à droite l'interpréteur MicroPython (Raspberry Pi Pico) et tape from umqtt.simple import MQTTClient dans la console. Si tu n'as pas d'erreur, la bibliothèque est déjà dans le firmware et il n'y a rien à installer.
- Si tu obtiens une ImportError, connecte la carte au Wi-Fi avec le code ci-dessous et télécharge la bibliothèque directement depuis Internet avec mip.
- Autre option : dans Thonny, ouvre Outils > Gérer les paquets, cherche micropython-umqtt.simple et installe-le.
- Après l'installation, tu dois voir le fichier /lib/umqtt/simple.py dans le système de fichiers 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ı / optionalChoisir un broker MQTT gratuit
. Pour commencer, pas besoin de monter ton propre serveur. Plusieurs entreprises exploitent des brokers publics à des fins de test ; ils ne demandent ni identifiant ni mot de passe et tu peux envoyer ton premier message en quelques minutes. Pour un projet durable, installer Mosquitto sur un Raspberry Pi à la maison, un vieil ordinateur ou Home Assistant est la solution la plus solide : les données restent chez toi et, même sans Internet, les appareils du réseau local continuent à échanger des messages.
| Broker | Adresse | Port | Remarque |
|---|---|---|---|
| Broker public HiveMQ | broker.hivemq.com | 1883 (TCP) | Sans inscription, ouvert à tous |
| Serveur de test Eclipse Mosquitto | test.mosquitto.org | 1883 (sans chiffrement), 8883 (TLS) | Sans inscription, ouvert à tous |
| Broker public EMQX | broker.emqx.io | 1883 (TCP), 8883 (TLS) | Sans inscription, ouvert à tous |
| Add-on Mosquitto de Home Assistant | Adresse IP locale de Home Assistant | 1883 | Identifiant et mot de passe requis |
| Ton propre serveur Mosquitto | Adresse IP de ton Raspberry Pi ou ordinateur | 1883 | Contrôle total, fonctionne en local |
Pas à pas : publier la température et s'abonner à la LED
Le programme ci-dessous fait quatre choses à la fois : il se connecte au Wi-Fi, se connecte au broker avec un identifiant client unique, s'abonne au topic bluegrays/picow/led et publie toutes les dix secondes la valeur du capteur de température interne sur bluegrays/picow/sicaklik. Si "ON" arrive sur le topic de la LED, elle s'allume ; avec "OFF", elle s'éteint, et le nouvel état est signalé sur un autre topic avec le drapeau retain. Si tu enregistres le fichier sous le nom main.py dans la Pico avec Thonny, le programme démarre tout seul à chaque mise sous tension.
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)| Morceau de code | Ce qu'il fait |
|---|---|
| CLIENT_ID | Génère un identifiant propre à chaque carte avec machine.unique_id() ; deux appareils connectés avec le même identifiant se déconnectent mutuellement sur le broker |
| read_temp() | Convertit la valeur d'ADC(4) en tension, puis en degrés Celsius avec la formule 27 - (V - 0,706) / 0,001721 |
| set_last_will() | Fait écrire "offline" par le broker sur le topic d'état si la connexion tombe brutalement ; doit être appelé avant connect() |
| subscribe() | Commence à écouter le topic de la LED ; il est rappelé à chaque nouvelle connexion |
| check_msg() | Appelle la fonction on_message s'il y a un message reçu, sinon rend la main sans attendre |
| pending_state | Au lieu de publier dans le callback, on laisse l'état dans une variable et c'est la boucle principale qui publie |
| ticks_diff() | Mesure les dix secondes sans bloquer avec sleep ; les commandes de la LED sont ainsi traitées sans retard |
| reconnect() | Réessaie la connexion Wi-Fi et MQTT à intervalles de 2, 4, 8 … secondes, 60 au maximum |
Après avoir lancé le programme, connecte-toi au même broker avec MQTT Explorer sur ton ordinateur et abonne-toi au topic bluegrays/picow/#. Tu dois voir arriver la température toutes les dix secondes et "online" sur le topic d'état. Pour tester la LED, publie ON en majuscules sur le topic bluegrays/picow/led : la LED verte de la carte s'allume aussitôt et le message reçu s'affiche dans la console de Thonny. Si les outils clients Mosquitto sont installés, tu peux faire la même chose en ligne de commande avec mosquitto_pub -h broker.hivemq.com -t bluegrays/picow/led -m ON. Comme le capteur interne mesure la température de la puce elle-même, il peut afficher quelques degrés de plus que la pièce ; pour mesurer vraiment l'ambiance, branche un capteur externe comme le DHT11/DHT22 ou le BME280 et adapte la fonction read_temp().
Rétablir automatiquement la connexion perdue
Pour un objet connecté domestique, le pire ennemi est la perte de connexion : la box redémarre, le signal Wi-Fi faiblit ou le broker part en maintenance. Dans ce cas, umqtt.simple ne se rétablit pas tout seul ; il lève une OSError au prochain appel de publish() ou check_msg(). Le bloc try/except du programme attrape cette erreur et appelle reconnect(). La fonction ferme d'abord l'ancien socket, se reconnecte au Wi-Fi si besoin, puis rétablit la connexion MQTT et l'abonnement depuis le début. Après chaque échec, le délai d'attente double (2, 4, 8, 16, 32, 60 secondes) ; c'est ce qu'on appelle le backoff exponentiel, qui t'évite de noyer le broker sous des dizaines de tentatives par seconde.
La valeur du keepalive compte aussi. Dans le code, nous l'avons fixée à 60 secondes ; selon les règles MQTT, le broker ferme la connexion si aucun paquet du client n'arrive pendant 1,5 fois ce délai (soit 90 secondes). Comme nous publions toutes les dix secondes, il n'y a pas de problème. Mais si tu espaces les publications, par exemple à cinq minutes, tu dois ajouter régulièrement un appel à client.ping() ; umqtt.simple n'envoie pas le paquet ping automatiquement. Grâce au message Last Will, même si tu débranches la carte, le broker écrit "offline" sur le topic d'état à l'expiration du keepalive et Home Assistant affiche l'appareil comme "indisponible".
- Garde tes identifiants Wi-Fi et le mot de passe du broker dans un fichier secrets.py séparé, et ne partage pas ce fichier quand tu partages ton code.
- Pour la stabilité, active un chien de garde avec machine.WDT(timeout=8000) et appelle régulièrement wdt.feed() dans la boucle principale ; si le programme se bloque quelque part, la carte redémarre. Dans ce cas, garde aussi les attentes de reconnect() sous 8 secondes ou nourris le chien pendant l'attente.
- Ne publie pas la mesure à chaque tour de boucle, mais à intervalles réguliers ; pour réduire les fluctuations ponctuelles, fais la moyenne de plusieurs mesures (filtrage des données de capteur).
- Utilise retain pour les topics dont la dernière valeur compte, comme l'état de la LED ; n'envoie pas de message retain sur les topics de commande, sinon la carte réapplique l'ancienne commande à chaque reconnexion.
- Si la connexion tombe souvent, essaie de désactiver le mode d'économie d'énergie de la puce sans fil avec wlan.config(pm=0xa11140) ; cela réduit la latence mais augmente la consommation de courant.
Connecter la Pico W à Home Assistant
- Dans Home Assistant, installe et démarre l'add-on Mosquitto broker depuis Paramètres > Modules complémentaires.
- Dans Paramètres > Personnes, crée un utilisateur dédié à la Pico W (par exemple "pico") ; son nom et son mot de passe serviront pour la connexion MQTT.
- Dans Paramètres > Appareils et services, configure l'intégration MQTT détectée.
- Remplace la valeur BROKER dans le code par l'adresse IP locale de Home Assistant (par exemple 192.168.1.50) et renseigne MQTT_USER et MQTT_PASS avec le nom et le mot de passe de l'utilisateur.
- Ajoute la fonction ha_discovery() ci-dessous au code et appelle-la dans mqtt_connect(), après la ligne subscribe(), avec ha_discovery(c).
- En quelques secondes, un nouvel appareil nommé "Pico W" apparaît dans la liste, avec en dessous le capteur de température et l'interrupteur de la 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)Par défaut, Home Assistant écoute les topics qui commencent par le préfixe homeassistant/. Quand la Pico W envoie sur ces topics une configuration JSON avec le drapeau retain, Home Assistant crée automatiquement les entités : la configuration sensor affiche la température comme une valeur qu'on peut tracer en graphique, et la configuration switch ajoute un interrupteur marche/arrêt dans l'interface. Quand tu touches l'interrupteur, Home Assistant publie "ON" ou "OFF" sur le command_topic, la carte change la LED et écrit le nouvel état sur le state_topic ; l'interrupteur de l'interface reflète donc toujours l'état réel. Le champ availability_topic utilise le message Last Will pour griser les entités quand la carte s'éteint. Si tu veux voir la même structure côté ESP32, jette un œil à l'article ESP32, MQTT et Home Assistant.
Idées de projets avec la Pico W et MQTT
- Tableau de température et d'humidité des pièces : mets une Pico W et un DHT22 dans chaque pièce et suis toute la maison sur un seul écran avec des topics comme maison/salon/temperature.
- Lampe télécommandée : pilote un module relais à la place de la LED pour allumer et éteindre la lampe depuis Home Assistant.
- Notification d'arrosage des plantes : publie la valeur d'un capteur d'humidité du sol et envoie une notification sur ton téléphone par automatisation quand la terre est sèche.
- Alarme de mouvement : publie un message sur le topic maison/couloir/mouvement quand un capteur PIR se déclenche.
- Thermomètre d'aquarium : mesure la température de l'eau avec un DS18B20 et envoie un message d'alerte retain quand le seuil est dépassé.
- Comparaison avec l'interface web : pilote la même LED avec un serveur web sur Pico W pour voir la différence entre les deux méthodes.
Erreurs courantes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| ImportError: no module named 'umqtt' | La bibliothèque n'est pas dans le firmware | mip.install("umqtt.simple") ou le gestionnaire de paquets de Thonny |
| Le Wi-Fi ne se connecte jamais | Réseau 5 GHz, mauvais mot de passe ou signal faible | Utilise un réseau 2,4 GHz, affiche wlan.status(), rapproche la carte de la box |
| OSError pendant connect() | L'adresse du broker n'est pas résolue ou il n'y a pas de réseau | Vérifie d'abord wlan.isconnected(), écris correctement le nom du broker et le port |
| MQTTException : 4 ou 5 | Identifiant ou mot de passe incorrect, accès refusé | Vérifie l'utilisateur et le mot de passe Home Assistant |
| La connexion tombe au bout de 90 secondes environ | Aucun paquet n'est envoyé pendant le keepalive | Publie régulièrement ou ajoute client.ping() |
| Aucun message n'arrive | check_msg() n'est pas appelé dans la boucle ou set_callback() a été oublié | Appelle set_callback() avant subscribe() et utilise check_msg() dans la boucle |
| La comparaison est toujours fausse | Le topic et le message arrivent en bytes et tu compares avec un str | Utilise des constantes bytes comme b"ON" |
| Deux cartes se déconnectent sans cesse | Le même CLIENT_ID est utilisé | Génère un identifiant unique avec machine.unique_id() |
Une fois MQTT en place, chaque nouveau capteur ou sortie que tu ajoutes à la carte n'est qu'un nouveau topic ; l'infrastructure reste la même. Lance d'abord le programme de ce guide avec la LED intégrée et le capteur de température, puis étends-le avec un relais et des capteurs externes. Si tu veux consolider les bases de MicroPython comme la LED, le bouton et le PWM, tu trouveras dans les projets Raspberry Pi Pico de l'application BlueGrays le schéma de câblage et le code de chaque étape, pas à pas.
Questions fréquentes
Peut-on utiliser MQTT avec un Raspberry Pi Pico classique ?
Non, la Pico classique n'a ni Wi-Fi ni Ethernet et ne peut donc pas se connecter directement à un broker. Pour MQTT, il te faut une Pico W ou Pico 2 W avec puce sans fil. Une Pico classique ne peut accéder au réseau qu'avec un module Wi-Fi ou Ethernet externe, ce qui complique beaucoup le montage.
Quelle différence entre umqtt.simple et umqtt.robust ?
umqtt.simple est un client minuscule qui gère les opérations MQTT de base (connexion, publication, abonnement) et lève une erreur quand la connexion tombe. umqtt.robust est construit dessus et tente de se reconnecter automatiquement en cas d'erreur. Comme il ne renouvelle pas les abonnements tout seul, c'est toi qui dois rappeler subscribe() après la reconnexion.
Quel est le meilleur broker MQTT gratuit ?
Pour tester, broker.hivemq.com, test.mosquitto.org et broker.emqx.io sont des brokers publics sans inscription qui fonctionnent sur le port 1883. Comme ils sont ouverts à tous, n'y envoie que des données de test. Pour une installation durable et sûre, le meilleur choix gratuit est d'installer Mosquitto sur un Raspberry Pi à la maison ou sur Home Assistant.
Comment ajouter une Pico W à Home Assistant ?
Installe l'add-on Mosquitto broker et l'intégration MQTT dans Home Assistant, puis crée un utilisateur dédié à la Pico W. Connecte la carte à l'adresse IP de Home Assistant avec cet utilisateur et publie une configuration de découverte avec retain sur les topics commençant par homeassistant/. Home Assistant crée alors automatiquement le capteur et l'interrupteur.
Pourquoi la connexion MQTT de ma Pico W se coupe-t-elle ?
La cause la plus fréquente est l'absence de paquet pendant le délai de keepalive ; umqtt.simple n'envoie pas le ping automatiquement, il faut donc publier régulièrement ou appeler client.ping(). Un signal Wi-Fi faible, le redémarrage de la box et un second appareil utilisant le même identifiant client provoquent aussi des coupures. Écrire ton code pour attraper les OSError et se reconnecter règle tous ces cas.
Peut-on utiliser TLS (8883) avec MQTT sur la Pico W ?
Oui. Avec le paramètre ssl de umqtt.simple, tu peux établir une connexion chiffrée sur le port 8883 ; dans les versions récentes de MicroPython, on lui passe un contexte créé avec ssl.SSLContext. La négociation TLS peut prendre quelques secondes sur le RP2040 et augmente l'usage de la RAM. Les brokers cloud comme HiveMQ Cloud imposent généralement une connexion TLS.
Projets à réaliser après cet article
Voir tous les projets
Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
Le projet d'ouverture de la série Raspberry Pi Pico ! On fait clignoter la LED verte intégrée du Pico pour vérifier que la carte fonctionne : le classique premier essai façon "Hello World". Aucun composant externe, juste le Pico et un câble USB. Le code est écrit en MicroPython, le langage officiellement pris en charge par la Raspberry Pi Foundation.

Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
L'étape suivante après la LED intégrée du Pico : brancher une LED externe sur une plaque d'essai et la piloter par la broche GP14. Tu apprends à utiliser n'importe quelle broche GPIO du Pico en sortie, la polarité de la LED (patte longue = anode/+, patte courte = cathode/–) et pourquoi une résistance de limitation (220Ω) est indispensable. Sans elle, trop de courant traverse la LED, qui peut griller.

Raspberry Pi Pico LED Contrôlée par Bouton (Push)
Premier projet entrée avec Pico — lecture bouton ! LED s'allume tant que le bouton est pressé. Apprends Pin.IN, Pin.PULL_UP et button.value(). GP14 LED, GP2 bouton avec PULL_UP interne. Pressé = 0, relâché = 1 — standard.

Raspberry Pi Pico Bouton Toggle LED
Bouton + LED — niveau supérieur ! Contrairement au projet bouton de base, pas besoin de maintenir le bouton. Appuie et relâche → LED allumée. Réappuie → LED éteinte (toggle). Même circuit, mais grande différence de code. Apprends edge detection, state tracking et debounce.

Raspberry Pi Pico PWM LED Fade (Effet Respiration)
La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.

Raspberry Pi Pico LED RVB Cycle de Couleurs (PWM 3 Canaux)
Une LED, des millions de couleurs ! Une LED RVB contient 3 LEDs : rouge, verte et bleue. Avec un canal PWM du Pico pour chacune, les couleurs se mélangent : rouge + vert = jaune, vert + bleu = cyan, les trois = blanc. La LED parcourt 8 couleurs. Apprends plusieurs canaux PWM, les fonctions (def), le mélange RVB, la conversion 8 bits → 16 bits (x257) et cathode commune vs anode commune.

Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

