Projets Raspberry Pi Pico W : 15 idées Wi-Fi et Bluetooth
15 projets Raspberry Pi Pico W : serveur web, MQTT, horloge NTP, météo, Telegram et BLE. Code MicroPython, limites de mémoire et tableau Pico W ou ESP32.
Si tu cherches des projets Raspberry Pi Pico W, cette liste propose 15 projets réalistes pour exploiter le Wi-Fi et le Bluetooth de la carte, du plus simple au plus difficile : un serveur web qui allume une LED depuis le téléphone, une horloge NTP qui prend l'heure sur internet, une station qui publie des mesures en MQTT, une alarme qui envoie un message Telegram à l'ouverture d'une porte et un capteur de température BLE lu avec le téléphone n'en sont que quelques-uns. Tous fonctionnent avec le même code sur la Pico W et la nouvelle Pico 2 W.
Nous avons rassemblé dans un tableau les composants, le type de connexion et la difficulté de chaque projet, et nous donnons le code MicroPython complet des cinq plus importants. Tu trouveras ensuite les limites de mémoire de la Pico W sous MicroPython, les erreurs fréquentes et un tableau comparatif indiquant quels projets réussissent mieux avec une Pico W et lesquels avec un ESP32. Si c'est ta première fois avec la carte, jette d'abord un œil à qu'est-ce que la Raspberry Pi Pico.

Pico W et Pico 2 W : quelles différences ?
La Pico W est la Pico classique à laquelle on a ajouté une puce sans fil Infineon CYW43439 : elle offre le Wi-Fi 2,4 GHz (802.11n) et le Bluetooth 5.2 (Classic et BLE). La Pico 2 W associe la même puce au processeur RP2350, plus puissant ; la RAM double et la flash passe à 4 Mo. Le brochage, la taille et la plupart du code MicroPython sont identiques sur les deux cartes. Comme la puce sans fil occupe quelques broches internes, la LED intégrée n'est plus sur GP25 mais sur la puce sans fil, et on la pilote avec Pin("LED").
| Caractéristique | Pico W | Pico 2 W |
|---|---|---|
| Processeur | RP2040, 2 × Cortex-M0+, 133 MHz | RP2350, 2 × Cortex-M33 (ou RISC-V), 150 MHz |
| RAM | 264 Ko | 520 Ko |
| Flash | 2 Mo | 4 Mo |
| Sans fil | CYW43439 : Wi-Fi 4 2,4 GHz, Bluetooth 5.2 | CYW43439 : Wi-Fi 4 2,4 GHz, Bluetooth 5.2 |
| GPIO / ADC | 26 GPIO, 3 entrées analogiques (12 bits) | 26 GPIO, 3 entrées analogiques (12 bits) |
| LED intégrée | Pin("LED") | Pin("LED") |
| Firmware MicroPython | RPI_PICO_W | RPI_PICO2_W |
Avant de commencer : MicroPython et bibliothèques
- Installe le bon firmware : Utilise le fichier UF2 MicroPython RPI_PICO_W pour la Pico W et RPI_PICO2_W pour la Pico 2 W. Le firmware de la Pico simple n'a pas de module network, et le code Wi-Fi échoue avec "no module named network".
- Utilise Thonny : Dans Thonny, choisis en bas à droite "MicroPython (Raspberry Pi Pico)" ; il exécute le code, copie les fichiers sur la carte et synchronise son horloge avec ton ordinateur. Pour les commandes de base, vois le guide les bases de MicroPython.
- Installe les paquets supplémentaires avec mip : Une fois connecté au Wi-Fi, tape dans le Shell import mip; mip.install("umqtt.simple") ou mip.install("aioble") pour télécharger le paquet directement sur la carte. Le menu Outils > Gérer les paquets de Thonny fait la même chose.
- 2,4 GHz uniquement : La Pico W ne se connecte pas aux réseaux 5 GHz ; si ta box diffuse les deux bandes sous le même nom, la connexion peut poser problème.
- Alimentation : Pendant l'émission Wi-Fi, le courant de pointe peut dépasser 100 mA. Utilise un bon câble USB et un chargeur d'au moins 500 mA.
| Module | À quoi sert-il ? | Inclus ? |
|---|---|---|
| network | Connexion Wi-Fi, point d'accès, scan des réseaux | Oui (dans le firmware W) |
| socket / asyncio | Serveur web, UDP, tâches simultanées | Oui |
| requests | Requêtes HTTP et HTTPS, JSON | Oui |
| ntptime | Récupérer l'heure sur internet | Oui |
| bluetooth | BLE bas niveau | Oui |
| aioble | BLE simplifié : services, caractéristiques, annonces | Selon la version ; sinon mip.install("aioble") |
| umqtt.simple | Client MQTT | Selon la version ; sinon mip.install("umqtt.simple") |
Le code de connexion Wi-Fi utilisé dans tous les projets
Enregistre le fichier ci-dessous sur la Pico W dans Thonny sous le nom wifi.py. Dans tous les autres projets, il te suffira ensuite d'écrire import wifi et wifi.connect(). La LED intégrée clignote pendant la connexion et reste allumée une fois connectée ; c'est le moyen le plus simple de voir l'état de la connexion quand la carte n'est pas reliée à l'ordinateur.
1# wifi.py: Pico W'ye bu adla kaydet / save it to the Pico W with this name
2import network, time
3from machine import Pin
4
5SSID = "AgAdi" # Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
6PASSWORD = "Sifre123" # Wi-Fi şifren / your Wi-Fi password
7led = Pin("LED", Pin.OUT) # Pico W ve Pico 2 W dahili LED / onboard LED
8
9
10def connect(timeout=20):
11 network.country("TR") # ülke kodu: kanal ve güç sınırları / country code
12 wlan = network.WLAN(network.STA_IF)
13 wlan.active(True)
14 if not wlan.isconnected():
15 wlan.connect(SSID, PASSWORD)
16 for _ in range(timeout * 2):
17 if wlan.status() < 0 or wlan.status() == 3:
18 break
19 led.toggle() # bağlanırken yanıp söner / blinks while connecting
20 time.sleep(0.5)
21 if wlan.status() != 3:
22 led.off()
23 raise RuntimeError("Wi-Fi hatasi / error: %d" % wlan.status())
24 led.on() # bağlandı / connected
25 print("IP:", wlan.ifconfig()[0], "RSSI:", wlan.status("rssi"), "dBm")
26 return wlanwlan.status() indique à quelle étape en est la connexion : 3 signifie connectée avec une adresse IP, 1 connexion en cours, −2 réseau introuvable, −3 mot de passe erroné et −1 échec pour une autre raison. Dès que le code voit une valeur inférieure à 0, il arrête d'attendre et signale clairement l'erreur. Le RSSI est la force du signal : −50 dBm est très bon, −70 dBm acceptable, et à −80 dBm ou moins la connexion risque de couper. La ligne network.country("TR") règle les canaux et la puissance de la puce selon les règles du pays ; en France écris "FR", en Belgique "BE".
15 projets Raspberry Pi Pico W : tableau
| # | Projet | Connexion | Composants en plus | Difficulté |
|---|---|---|---|---|
| 1 | Se connecter au Wi-Fi et afficher l'état avec la LED intégrée | Wi-Fi | Aucun | Facile |
| 2 | Serveur web qui pilote une LED et un relais depuis le téléphone | Wi-Fi, HTTP | LED, module relais | Facile |
| 3 | Tableau de bord de température mis à jour en direct dans le navigateur | Wi-Fi, HTTP + JSON | Capteur interne ou DHT22 | Moyen |
| 4 | Horloge NTP qui prend l'heure sur internet (avec OLED) | Wi-Fi, NTP | OLED 0,96" | Facile |
| 5 | Mode point d'accès (AP) pour piloter sans box | Wi-Fi AP | Aucun | Moyen |
| 6 | Scanner de réseaux Wi-Fi et mesure du signal | Wi-Fi | OLED (optionnel) | Facile |
| 7 | Publier des mesures en MQTT | Wi-Fi, MQTT | Capteur interne | Moyen |
| 8 | Capteur qui rejoint Home Assistant en MQTT | Wi-Fi, MQTT | DHT22 | Moyen |
| 9 | Afficheur météo | Wi-Fi, HTTPS + JSON | OLED | Moyen |
| 10 | Alerte Telegram à l'ouverture d'une porte | Wi-Fi, HTTPS | ILS (reed) ou PIR | Moyen |
| 11 | Messages entre deux Pico W en UDP | Wi-Fi, UDP | Deuxième Pico W, bouton, LED | Moyen |
| 12 | Enregistrement de données et graphiques sur ThingSpeak | Wi-Fi, HTTP | N'importe quel capteur | Facile |
| 13 | Capteur de température BLE lu par le téléphone | BLE | Aucun | Moyen |
| 14 | Télécommande BLE d'une LED ou d'un servo depuis le téléphone | BLE (service UART) | LED ou servo | Difficile |
| 15 | Clavier Bluetooth et télécommande de présentation | BLE HID (Arduino IDE) | 2 boutons | Difficile |
Niveau 1 : projets Wi-Fi et web (1–6)
Le premier projet, c'est le wifi.py ci-dessus lui-même ; la LED qui clignote pendant la connexion puis reste allumée est un petit indicateur bien pratique. Dans le deuxième, la Pico W devient un serveur web : quand tu ouvres son adresse IP sur le téléphone, les boutons ALLUMER et ÉTEINDRE de la page envoient /on ou /off dans l'adresse ; le code le lit et commute la LED ou le relais. Un exemple complet en socket et le câblage du relais sont dans le guide serveur web Pico W. Dans le troisième, la page ne se recharge pas : un petit JavaScript dans le navigateur récupère du JSON sur /data toutes les deux secondes, et la Pico W lit son capteur de température interne (ADC4) ou un DHT22 pour le servir à cette adresse. La page se met ainsi à jour en direct sans clignoter.
Le quatrième projet est une horloge de bureau qui prend l'heure sur internet. ntptime.settime() règle l'horloge interne de la carte en UTC ; en France, il faut ajouter une heure en hiver et deux en été, et calculer le changement d'heure dans le code. Dans le cinquième, la Pico W ne rejoint pas une box mais crée son propre réseau : tu connectes ton téléphone au réseau "PicoW" créé avec network.WLAN(network.AP_IF) et tu ouvres la page de commande à l'adresse 192.168.4.1 ; très utile au jardin ou en classe, partout où il n'y a pas de box. Le sixième utilise wlan.scan() pour lister les réseaux proches avec leur canal et la force de leur signal ; promène la Pico W dans différents coins de la maison et choisis l'emplacement d'un capteur d'après le RSSI.
1import time, ntptime
2import wifi
3
4UTC_OFFSET = 3 * 3600 # Türkiye UTC+3; kendi saat dilimin / your own time zone
5wifi.connect()
6ntptime.settime() # dahili saati UTC'ye ayarla / set the internal clock to UTC
7
8while True:
9 t = time.localtime(time.time() + UTC_OFFSET)
10 print("%02d:%02d:%02d %02d.%02d.%04d" % (t[3], t[4], t[5], t[2], t[1], t[0]))
11 if t[4] == 0 and t[5] == 0: # her saat başı yeniden eşitle / resync every hour
12 try:
13 ntptime.settime()
14 except OSError:
15 pass
16 time.sleep(1)Niveau 2 : services internet : MQTT, météo, Telegram (7–12)
MQTT est le moyen de communication le plus répandu entre objets connectés : la Pico W envoie sa mesure vers un sujet (topic) sur un serveur broker, et le téléphone, l'ordinateur ou Home Assistant abonnés à ce sujet reçoivent le message instantanément. Inutile de connaître l'adresse IP de la carte ou d'ouvrir des ports sur la box. Dans le septième projet, nous publions le capteur de température interne toutes les dix secondes ; dans le huitième, un capteur DHT22 qui envoie un message MQTT Discovery sur le même principe apparaît tout seul dans Home Assistant. La configuration côté Home Assistant est expliquée dans le guide ESP32, MQTT et Home Assistant et s'applique telle quelle à la Pico W.
1import time
2from machine import ADC
3from umqtt.simple import MQTTClient
4import wifi
5
6BROKER = "test.mosquitto.org" # kendi broker'ın / your own broker
7TOPIC = b"bluegrays/picow/sicaklik"
8sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
9
10
11def read_temp():
12 volts = sensor.read_u16() * 3.3 / 65535
13 return 27 - (volts - 0.706) / 0.001721
14
15
16wifi.connect()
17client = MQTTClient("picow-bluegrays", BROKER, keepalive=60)
18client.connect()
19
20while True:
21 msg = "%.1f" % read_temp()
22 client.publish(TOPIC, msg.encode()) # her 10 sn yayınla / publish every 10 s
23 print("gonderildi / sent:", msg)
24 time.sleep(10)Le neuvième projet est un afficheur météo : la Pico W utilise requests pour envoyer une requête HTTPS à un service météo gratuit sans clé d'API, puis prend dans la réponse JSON la température et le code météo et les écrit sur l'OLED. La mémoire compte ici : pour garder une réponse légère, ne demande que les champs dont tu as besoin. Le dixième est l'un des plus utiles à la maison : quand un ILS fixé sur la porte s'ouvre, la Pico W t'envoie aussitôt un message sur le téléphone via un bot Telegram. Les étapes pour créer le bot et obtenir le jeton et le chat ID sont dans le guide bot Telegram ESP32 ; à la fin de ce même guide, il y a aussi une version Pico W plus complète qui accepte des commandes.
1import time, requests
2from machine import Pin
3import wifi
4
5TOKEN = "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # BotFather token'ı / token from BotFather
6CHAT_ID = 123456789 # kendi Telegram ID'n / your Telegram ID
7URL = "https://api.telegram.org/bot%s/sendMessage" % TOKEN
8door = Pin(15, Pin.IN, Pin.PULL_UP) # reed röle -> GND; kapı açılınca 1 / reed switch, 1 when open
9
10
11def send(text):
12 try:
13 r = requests.post(URL, json={"chat_id": CHAT_ID, "text": text})
14 r.close() # belleği geri ver / free the memory
15 except OSError as e:
16 print("gonderilemedi / failed:", e)
17
18
19wifi.connect()
20last = door.value()
21while True:
22 now = door.value()
23 if now != last:
24 send("Kapi acildi / door opened" if now else "Kapi kapandi / door closed")
25 last = now
26 time.sleep_ms(100)Dans le onzième projet, deux Pico W du même réseau s'envoient des paquets UDP : tu appuies sur le bouton de l'une et la LED de l'autre s'allume. UDP fonctionne sans établir de connexion, il est donc très rapide et tient en quelques lignes, mais il ne garantit pas l'arrivée du paquet ; pour les commandes importantes, mieux vaut attendre une courte réponse "reçu" de l'autre côté. Dans le douzième, les mesures sont envoyées toutes les 20 secondes par requête HTTP à un service IoT gratuit comme ThingSpeak ; le service stocke les données et trace des graphiques prêts à l'emploi dans le navigateur. N'oublie pas que les offres gratuites limitent la fréquence d'envoi.
Niveau 3 : projets Bluetooth (13–15)
Sous MicroPython, le Bluetooth de la Pico W s'utilise en BLE (Bluetooth Low Energy). Un appareil BLE propose un ou plusieurs services, et chaque service contient des caractéristiques que l'on peut lire ou qui envoient des notifications. Dans le treizième projet, nous utilisons le service standard Environmental Sensing (0x181A) et la caractéristique Temperature (0x2A6E), si bien que des applications BLE génériques comme nRF Connect affichent directement la valeur en °C. Le code repose sur le paquet aioble ; s'il manque sur ta carte, installe-le d'abord avec mip. Les notions BLE sont détaillées dans le guide ESP32, Bluetooth et BLE.
1import asyncio, struct, bluetooth, aioble
2from machine import ADC
3
4ENV_SENSE = bluetooth.UUID(0x181A) # Environmental Sensing servisi / service
5TEMP_CHAR = bluetooth.UUID(0x2A6E) # Temperature karakteristiği / characteristic
6sensor = ADC(4)
7
8service = aioble.Service(ENV_SENSE)
9temp_char = aioble.Characteristic(service, TEMP_CHAR, read=True, notify=True)
10aioble.register_services(service)
11
12
13def read_temp():
14 volts = sensor.read_u16() * 3.3 / 65535
15 return 27 - (volts - 0.706) / 0.001721
16
17
18async def measure():
19 while True:
20 t = int(read_temp() * 100) # 0,01 °C birimi / unit of 0.01 °C
21 temp_char.write(struct.pack("<h", t), send_update=True)
22 await asyncio.sleep(2)
23
24
25async def advertise():
26 while True:
27 async with await aioble.advertise(
28 250_000, name="PicoW-Temp", services=[ENV_SENSE], appearance=768
29 ) as connection:
30 print("baglandi / connected:", connection.device)
31 await connection.disconnected(timeout_ms=None)
32
33
34async def main():
35 await asyncio.gather(measure(), advertise())
36
37
38asyncio.run(main())Dans le quatorzième projet, la Pico W imite un schéma BLE très courant appelé Nordic UART Service (NUS) ; les textes comme "on", "off" ou "90" envoyés depuis une application de terminal BLE sur le téléphone allument la LED ou font tourner le servo sur la Pico W. Le quinzième s'écrit dans l'IDE Arduino : la bibliothèque KeyboardBLE du cœur Raspberry Pi Pico/RP2040 d'Earle Philhower fait apparaître la Pico W comme un clavier Bluetooth auprès des ordinateurs et des téléphones. Après avoir activé la pile Bluetooth dans le menu Outils, tu peux fabriquer avec deux boutons une télécommande qui passe à la diapositive suivante et précédente pendant tes présentations.
Limites de mémoire et stabilité
La mémoire que MicroPython peut utiliser sur une Pico W n'est qu'une partie des 264 Ko de RAM de la carte ; le firmware, le pilote Wi-Fi et les tampons réseau occupent le reste. C'est largement suffisant pour des projets simples, mais quand requêtes HTTPS, grosses réponses JSON et longues pages HTML se cumulent, un MemoryError peut apparaître. Chaque connexion HTTPS réserve temporairement 30–50 Ko pour le chiffrement, et une réponse JSON de 20 Ko occupe la mémoire deux fois, d'abord sous forme de texte puis de dictionnaire. La RAM doublée de la Pico 2 W allège beaucoup cette limite.
| Ressource | Pico W | Pico 2 W | Remarque |
|---|---|---|---|
| RAM totale | 264 Ko | 520 Ko | Une partie sert au firmware et au Wi-Fi |
| Mémoire libre au démarrage (gc.mem_free) | Environ 150–190 Ko | Environ 400 Ko ou plus | Varie selon la version ; mesure sur ta carte |
| Flash / système de fichiers | 2 Mo / environ 850 Ko | 4 Mo / plus de 2 Mo | Le code, le HTML et les journaux y sont stockés |
| Une connexion HTTPS | 30–50 Ko temporaires | 30–50 Ko temporaires | Libère-la avec r.close() une fois terminé |
| Wi-Fi et BLE ensemble | Fonctionne, la mémoire devient encore plus juste | Tourne à l'aise | Teste chacun séparément, puis combine |
Pico W ou ESP32 ? Quel projet pour quelle carte ?
| Type de projet | Pico W | ESP32 | Recommandation |
|---|---|---|---|
| Serveur web simple, commande de LED et de relais | Sans problème | Sans problème | Les deux ; Pico W si tu apprends MicroPython |
| Capteur MQTT et Home Assistant | Fonctionne bien | Très bien, sans code avec ESPHome | ESP32 |
| Caméra et transmission d'images | Non disponible | Possible avec l'ESP32-CAM | ESP32 |
| Capteur qui tient des mois sur piles | Sous MicroPython, le courant de veille reste élevé | Quelques microampères en deep sleep | ESP32 |
| Audio Bluetooth Classic (enceinte A2DP) | Prise en charge limitée | Pris en charge par l'ESP32 classique | ESP32 |
| Clavier BLE, télécommande | Facile avec arduino-pico | Facile avec des bibliothèques | Les deux |
| WS2812B, timing précis, protocoles maison | Très puissant avec le PIO | Bien avec le RMT | Pico W |
| Mesure analogique | 3 canaux, ADC 12 bits linéaire | Nombreux canaux mais non linéaire ; ADC2 inutilisable avec le Wi-Fi actif | Pico W si peu de canaux suffisent |
En bref, la Pico W est excellente pour apprendre MicroPython, pour les tâches matérielles qui exigent un timing précis et pour les projets réseau simples ; elle est bien documentée, stable et très facile à programmer avec Thonny. S'il te faut une caméra, une longue autonomie sur piles, de l'audio Bluetooth ou un écosystème prêt à l'emploi comme ESPHome, l'ESP32 est le meilleur choix. Pour comparer les versions ESP32 de projets comme une horloge internet, un serveur web ou un afficheur météo, le guide horloge NTP ESP32 est un bon point de départ.
Erreurs fréquentes et solutions
- ImportError: no module named 'network' : La carte a le firmware de la Pico simple. Installe le fichier UF2 RPI_PICO_W ou RPI_PICO2_W.
- La LED intégrée ne s'allume pas : Pin(25) a été utilisé. Sur la Pico W et la Pico 2 W, la bonne forme est Pin("LED", Pin.OUT).
- wlan.status() renvoie −2 : Réseau introuvable ; vérifie le nom du réseau en respectant les majuscules et minuscules, et assure-toi que la bande 2,4 GHz est active.
- OSError: [Errno 98] EADDRINUSE : Le port 80 est encore occupé après le redémarrage du serveur web. Fais un redémarrage logiciel avec Ctrl+D ou utilise SO_REUSEADDR sur le socket.
- MemoryError : Un gros JSON ou HTML a rempli la mémoire. Réduis les réponses, utilise r.close() et gc.collect(), et passe à une Pico 2 W si besoin.
- Le code marche depuis l'ordinateur mais pas sur un chargeur : Le fichier n'a pas été enregistré sous main.py, ou le code compte sur l'horloge réglée par Thonny. Nomme le fichier main.py et règle toi-même l'heure avec ntptime.
Une fois ces 15 projets réalisés, tu auras utilisé le Wi-Fi, HTTP, NTP, MQTT, UDP et BLE avec la Pico W et posé les bases pour concevoir tes propres objets connectés. Dans l'application BlueGrays, tu peux consulter les schémas pas à pas et le code de projets Pico de base, comme allumer une LED, un feu tricolore, la variation d'une LED en PWM et un cycle de couleurs RVB, ainsi que de projets ESP32 comme la connexion Wi-Fi, une horloge NTP et un serveur web, pour compléter chaque projet côté matériel aussi.
Questions fréquentes
Que peut-on faire avec une Raspberry Pi Pico W ?
Avec une Pico W, tu peux créer des serveurs web pilotés depuis le téléphone, des horloges NTP qui prennent l'heure sur internet, des capteurs qui envoient leurs données en MQTT, des alarmes avec alertes Telegram et des appareils qui dialoguent avec le téléphone en BLE. Grâce à ses 26 broches GPIO, ajouter capteurs, relais, écrans et LED est facile. Le code s'écrit en MicroPython ou avec l'IDE Arduino.
Quelle est la différence entre la Pico W et la Pico 2 W ?
Les deux utilisent la même puce Wi-Fi et Bluetooth CYW43439. La Pico 2 W a le processeur RP2350, plus rapide, deux fois plus de RAM (520 Ko) et 4 Mo de flash. Le brochage est identique et la plupart du code MicroPython fonctionne sans modification.
La Pico W peut-elle se connecter à un Wi-Fi 5 GHz ?
Non, la Pico W et la Pico 2 W ne se connectent qu'aux réseaux 2,4 GHz. Si ta box diffuse les deux bandes sous le même nom, la connexion peut échouer ; donner un nom propre à la bande 2,4 GHz ou tester avec le partage de connexion 2,4 GHz du téléphone aide en général.
Pourquoi la LED intégrée de la Pico W ne s'allume-t-elle pas avec Pin(25) ?
Sur la Pico W, GP25 sert de ligne de sélection de la puce sans fil et la LED intégrée a été déplacée sur cette puce. La bonne écriture est Pin("LED", Pin.OUT). Elle fonctionne de la même façon sur la Pico classique, la Pico W et la Pico 2 W.
Le Bluetooth de la Pico W est-il pris en charge par MicroPython ?
Oui, MicroPython prend en charge le BLE sur la Pico W. Le module bluetooth bas niveau est fourni avec le firmware et, pour plus de simplicité, le paquet aioble s'installe avec mip. Des fonctions comme l'audio Bluetooth Classic ne sont en revanche pas disponibles sous MicroPython.
Pour un projet IoT, vaut-il mieux une Pico W ou un ESP32 ?
Pour apprendre MicroPython, réaliser des projets réseau simples et des tâches qui exigent un timing précis, la Pico W est un très bon choix. S'il te faut une caméra, des mois d'autonomie sur piles, de l'audio Bluetooth ou un écosystème prêt comme ESPHome, l'ESP32 convient mieux. Les deux gèrent sans peine des projets simples de serveur web et de MQTT.
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.

Simulateur de Feu de Circulation Raspberry Pi Pico (3 LEDs séquentielles)
Nous simulons un vrai feu de circulation avec des LEDs rouge, jaune et verte. Vert 4 sec "passez", jaune 1,5 sec "préparez", rouge 3 sec "arrêtez" et rouge+jaune 1 sec "départ" (motif européen). Apprends la définition de fonction, la logique de machine à états et la synchronisation multi-GPIO. Circuit simple : 3 LEDs sur GP11/GP12/GP13, chacune avec 220Ω.

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.

ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

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

