Guides · 12 min de lecture

Projets Raspberry Pi Pico : 20 idées pour débuter, code inclus

20 projets Raspberry Pi Pico pour débutants : LED, interruption de bouton, PWM, capteurs, OLED et servo, avec un tableau langage, composants et difficulté.

Tu cherches des projets Raspberry Pi Pico et tu ne sais pas par où commencer ? Cette liste est faite pour toi : nous avons réuni 20 projets classés du plus facile au plus difficile, de la simple LED qui clignote et de l'interruption de bouton à l'effet respiration en PWM, à la lecture de capteurs, à l'écran OLED et au servomoteur. Un seul tableau t'indique pour chaque projet le langage conseillé (MicroPython ou C/C++), les composants nécessaires et la difficulté, et le projet le plus formateur de chaque niveau est livré avec un code qui fonctionne.

Trois raisons font du Pico une excellente première carte : il coûte peu, MicroPython exécute ton code sans attendre une compilation et chacune de ses 26 broches GPIO peut produire du PWM. Si tu viens de le déballer, suis d'abord les étapes d'installation de Qu'est-ce que le Raspberry Pi Pico ? ; ici, on part du principe que ta carte fonctionne déjà dans Thonny et que tu sais faire clignoter la LED intégrée.

Carte microcontrôleur Raspberry Pi Pico
Raspberry Pi Pico : puce RP2040, 26 GPIO, 3 entrées analogiques et du PWM sur chaque broche. Tous les projets de cette liste fonctionnent sur le Pico, le Pico W et le Pico 2.

Avant de commencer : le matériel nécessaire

  • Carte : Raspberry Pi Pico, Pico W ou Pico 2. Le projet sans fil (le numéro 19) demande un Pico W.
  • Plaque d'essai et fils de connexion : pour monter les circuits sans soudure ; vérifie que les connecteurs de ton Pico sont bien soudés.
  • LED et résistances : 5 à 10 LED et des résistances de 220 Ω et 330 Ω ; pour choisir la valeur, utilise le calculateur de résistance pour LED.
  • Entrées : 2 ou 3 boutons-poussoirs, un potentiomètre de 10 kΩ, une photorésistance (LDR) et une résistance de 10 kΩ.
  • Capteurs et sorties : HC-SR04, DHT11, PIR HC-SR501, un buzzer passif, un servo SG90, un écran OLED SSD1306 de 0,96 pouce et un anneau WS2812B de 8 à 12 LED.
  • Logiciels : Thonny pour MicroPython ; l'IDE Arduino avec le core RP2040 d'Earle Philhower pour le C/C++.

MicroPython ou C/C++ ?

Le Pico gère les deux mondes et la plupart des projets de cette liste peuvent s'écrire dans l'un ou l'autre langage. En MicroPython, tu tapes ton code dans Thonny, tu cliques sur Exécuter et tu vois le résultat en une seconde ; en cas d'erreur, tu obtiens un message clair avec le numéro de ligne. Le C/C++ (IDE Arduino ou Pico SDK) demande une compilation, mais s'exécute 10 à 100 fois plus vite et te donne accès à des milliers de bibliothèques écrites pour Arduino. Si tu débutes, fais les 19 premiers projets en MicroPython et passe au C/C++ quand tu as besoin de vitesse ou d'une bibliothèque toute faite.

CritèreMicroPythonC/C++ (IDE Arduino)
Prise en mainFacile, des bases de Python suffisentFamilier si tu connais Arduino
Exécuter le codeImmédiat (avec Thonny)Compilation et téléversement : 10 à 30 secondes
VitessePlus lent, mais suffisant pour la plupart des projets10 à 100 fois plus rapide
BibliothèquesModules intégrés comme machine, neopixel, dhtLa plupart des bibliothèques Arduino
Idéal pourApprendre, lire des capteurs, tester viteTiming précis, clavier USB, calculs lourds

20 projets Raspberry Pi Pico : langage, composants et difficulté

#ProjetLangage conseilléComposants nécessairesDifficulté
1Faire clignoter la LED intégrée (Blink)MicroPythonLe Pico seulFacile
2LED externe (GP14)MicroPythonLED, résistance de 220 ΩFacile
3Feu tricoloreMicroPythonLED rouge, jaune et verte, 3 résistancesFacile
4Gyrophare de policeMicroPythonLED rouge et bleue, 2 résistancesFacile
5Chenillard K2000 (Knight Rider)MicroPython6 LED, 6 résistancesFacile
6Allumer et éteindre une LED avec un boutonMicroPythonBouton, LED, résistanceFacile
7Interruption de bouton (IRQ) et anti-rebondMicroPythonBouton, LED, résistanceMoyen
8LED qui respire en PWMMicroPythonLED, résistanceFacile
9Cycle de couleurs avec une LED RGBMicroPythonLED RGB, 3 résistancesFacile
10Mélodie avec un buzzer passifMicroPythonBuzzer passifFacile
11Luminosité d'une LED au potentiomètreMicroPythonPotentiomètre de 10 kΩ, LEDFacile
12Capteur de température interneMicroPythonLe Pico seulFacile
13Veilleuse automatique avec LDRMicroPythonLDR, résistance de 10 kΩ, LEDFacile
14Alarme de mouvement avec PIRMicroPythonHC-SR501, buzzer actifFacile
15Télémètre avec HC-SR04MicroPythonHC-SR04, résistances de 1 kΩ et 2 kΩMoyen
16Thermomètre à écran OLEDMicroPythonOLED SSD1306, DHT11Moyen
17Piloter un servo au potentiomètreMicroPythonServo SG90, potentiomètre de 10 kΩMoyen
18Animation sur un anneau WS2812BMicroPythonAnneau WS2812B (8 à 12 LED)Moyen
19Commander une LED en Wi-Fi avec le Pico WMicroPythonPico W, LEDDifficile
20Clavier de macros USBC/C++ (IDE Arduino)3 ou 4 boutonsDifficile

L'ordre n'a rien d'aléatoire : chaque projet ajoute une marche à ce que tu as appris dans le précédent. Les six premiers t'apprennent les sorties et entrées numériques, les projets 7 à 10 les interruptions et le PWM, 11 à 15 les capteurs analogiques et numériques, 16 à 18 l'écran, le servo et les LED pilotées par PIO, et les deux derniers des capacités propres au Pico comme le Wi-Fi et l'USB. Plus bas, on détaille chaque niveau avec son montage et on te donne le code des projets les plus formateurs.

Niveau 1 : projets LED et bouton (1–6)

Dans le premier projet, tu fais clignoter la LED intégrée avec Pin(25) (sur le Pico W et le Pico 2 W, avec Pin("LED")). Dans le deuxième, tu branches une LED externe sur GP14 (broche physique 19) à travers une résistance de 220 Ω ; la résistance peut se placer côté patte longue ou côté patte courte, l'important est qu'elle soit en série. Le feu tricolore allume tour à tour les trois LED de GP11, GP12 et GP13, le gyrophare fait clignoter une LED rouge et une bleue par salves rapides, et le chenillard K2000 promène un point lumineux d'avant en arrière sur six LED de GP9 à GP14. Dans ces trois projets, ranger les broches dans une liste et la parcourir avec une boucle for réduit ton code de moitié.

Dans le sixième projet, le bouton va sur GP2 et son autre patte sur GND, et on active la résistance de rappel (pull-up) interne du Pico : relâché, la broche lit 1 ; appuyé, elle lit 0. Pour que chaque appui inverse l'état de la LED, tu dois garder l'état précédent du bouton dans une variable et ne compter que le passage de 1 à 0. Pourquoi les boutons rebondissent et comment fonctionne le pull-up, on l'explique dans Comment brancher un bouton sur Arduino ; les mêmes règles valent pour le Pico.

Niveau 2 : interruption de bouton, PWM et son (7–10)

Vérifier le bouton en boucle (polling) suffit pour les projets simples, mais ton code peut rater des appuis pendant qu'il fait autre chose. Avec une interruption (IRQ), le Pico appelle ta fonction à l'instant où le niveau de la broche change. Le code ci-dessous est le projet 7 complet : chaque appui inverse la LED de GP14, et un filtre temporel de 200 ms empêche le rebond mécanique d'être compté comme un double appui.

MicroPython
1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT)                     # GP14 + 220 Ω direnç / GP14 + 220 Ω resistor
5button = Pin(2, Pin.IN, Pin.PULL_UP)       # butonun diğer ucu GND / other leg to GND
6last_ms = 0                                # son geçerli basış / last valid press
7
8def on_press(pin):
9    global last_ms
10    now = time.ticks_ms()
11    if time.ticks_diff(now, last_ms) > 200:   # 200 ms sıçrama filtresi / 200 ms debounce
12        led.toggle()
13        last_ms = now
14
15button.irq(trigger=Pin.IRQ_FALLING, handler=on_press)   # basınca 1→0 / press pulls 1→0
16
17while True:
18    time.sleep(1)                          # ana döngü boşta, iş kesmede / main loop idle, work in the IRQ
Garde la fonction d'interruption courte : pas de longues séries de print, pas de time.sleep et pas de création de grandes listes à l'intérieur. Le plus propre est de ne changer qu'une variable drapeau dans l'interruption et de faire le vrai travail dans la boucle principale. Pour comparer des instants, utilise toujours time.ticks_diff() ; le résultat reste juste même quand le compteur déborde.

Le projet huit est l'exemple type du PWM. Toutes les broches GPIO du Pico peuvent produire du PWM et, en MicroPython, le rapport cyclique se règle avec duty_u16() entre 0 et 65535. Si tu augmentes la luminosité de façon linéaire, l'œil ne la perçoit pas naturellement : la variation semble trop rapide à bas niveau et trop lente à haut niveau. Le code ci-dessous utilise une courbe cosinus pour un rythme de respiration doux et élève la valeur au carré pour se rapprocher de la perception de l'œil. La théorie se trouve dans Qu'est-ce que le PWM ?

MicroPython
1from machine import Pin, PWM
2import math, time
3
4led = PWM(Pin(14))
5led.freq(1000)                             # 1 kHz, titreme görünmez / 1 kHz, no visible flicker
6
7while True:
8    for step in range(200):
9        level = (1 - math.cos(step / 200 * 2 * math.pi)) / 2   # 0 → 1 → 0 yumuşak / smooth 0 → 1 → 0
10        led.duty_u16(int(level * level * 65535))             # kare alma göze doğal gelir / squaring looks natural
11        time.sleep_ms(15)                                      # 200 × 15 ms = 3 s bir nefes / one 3 s breath

Dans le projet neuf, tu appliques la même idée à trois canaux : relie les pattes rouge, verte et bleue d'une LED RGB à GP11, GP12 et GP13, chacune avec sa résistance, et décale les trois valeurs de duty pour que les couleurs se fondent les unes dans les autres. Avec une LED à anode commune, pense à inverser les valeurs ; les détails sont dans Utiliser une LED RGB. Dans le projet dix, tu changes plutôt la fréquence du PWM : branche un buzzer passif sur une broche, écris freq(440) et il joue un la ; un duty de 32768 (50 %) donne le son le plus fort, et une boucle sur une liste de notes te donne une mélodie.

Niveau 3 : projets avec capteurs (11–15)

Les entrées analogiques du Pico sont GP26, GP27 et GP28, et read_u16() renvoie une valeur de 0 à 65535 (la puce mesure en interne sur 12 bits et MicroPython ramène le résultat sur 16 bits). Dans le projet onze, tu relies le curseur d'un potentiomètre à GP26 et tu écris la mesure directement comme duty de la LED. Le projet douze ne demande aucun composant : le canal 4 de l'ADC est relié à un capteur de température dans la puce, et la température vaut T = 27 − (U − 0,706) / 0,001721. Comme il mesure la puce et non la pièce, il peut s'écarter de quelques degrés. Dans le projet treize, tu montes un pont diviseur avec la LDR et une résistance de 10 kΩ et tu allumes une LED quand la mesure dépasse un seuil d'obscurité ; le calculateur de pont diviseur te simplifie le calcul.

Le capteur PIR HC-SR501 du projet quatorze s'alimente en 5 V, mais sa sortie est en 3,3 V : elle peut donc aller directement sur un GPIO ; quand il détecte un mouvement, la broche passe à 1 pendant quelques secondes. Pour ses réglages de durée et de sensibilité, vois Capteur de mouvement PIR. Le projet quinze demande un peu plus d'attention : le HC-SR04 fonctionne en 5 V et sa broche ECHO renvoie une impulsion de 5 V. Le code ci-dessous envoie une impulsion de 10 microsecondes sur TRIG, mesure la durée de l'écho avec time_pulse_us() et en déduit la distance grâce à la vitesse du son.

MicroPython
1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(17, Pin.OUT)                    # GP17 → TRIG
5echo = Pin(16, Pin.IN)                     # GP16 ← ECHO (1 kΩ + 2 kΩ bölücüyle / through a 1k + 2k divider)
6
7def distance_cm():
8    trig.low()
9    time.sleep_us(2)
10    trig.high()
11    time.sleep_us(10)                      # 10 µs tetik darbesi / 10 µs trigger pulse
12    trig.low()
13    t = time_pulse_us(echo, 1, 30000)      # en çok 30 ms bekle (~5 m) / wait up to 30 ms (~5 m)
14    if t < 0:
15        return None                        # yankı yok / no echo
16    return t * 0.0343 / 2                  # 343 m/s, gidiş-dönüş / round trip
17
18while True:
19    d = distance_cm()
20    print("Mesafe / Distance:", "---" if d is None else "%.1f cm" % d)
21    time.sleep_ms(200)
Ne branche pas directement la broche ECHO du HC-SR04 sur le Pico : ses broches ne supportent pas le 5 V. Mets une résistance de 1 kΩ entre ECHO et GP16 et une de 2 kΩ entre GP16 et GND ; l'impulsion de 5 V descend ainsi à environ 3,3 V. Avec les versions 3,3 V, le HC-SR04P ou le RCWL-1601, le pont diviseur devient inutile.

Niveau 4 : écran OLED, servo et NeoPixel (16–18)

Dans le projet seize, tu affiches sur un OLED de 0,96 pouce la température et l'humidité mesurées par un DHT11. Le module dht dont le DHT11 a besoin est déjà inclus dans le firmware MicroPython du Pico ; pour l'OLED, tu copies le pilote ssd1306.py sur le Pico. L'écran se branche en I2C sur GP4 (SDA) et GP5 (SCL). Le code de l'écran est détaillé dans Utiliser un écran OLED SSD1306, celui du capteur dans Capteur de température et d'humidité DHT11.

Dans le projet dix-sept, tu fais tourner un servo SG90 avec un potentiomètre. Un servo attend un signal de 50 Hz et lit l'angle dans la largeur de l'impulsion : environ 500 microsecondes pour 0 degré et 2500 microsecondes pour 180 degrés. En MicroPython, duty_ns() te permet d'écrire la largeur d'impulsion directement en nanosecondes, ce qui rend le calcul très simple :

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15))                       # GP15 → servo sinyal (turuncu) / signal (orange)
5servo.freq(50)                             # 50 Hz = 20 ms periyot / 20 ms period
6pot = ADC(26)                              # GP26 (ADC0) ← potansiyometre orta ucu / pot wiper
7
8def set_angle(angle):
9    pulse_us = 500 + angle * 2000 // 180   # 0° = 500 µs, 180° = 2500 µs
10    servo.duty_ns(pulse_us * 1000)
11
12while True:
13    angle = pot.read_u16() * 180 // 65535  # 0–65535 → 0–180°
14    set_angle(angle)
15    time.sleep_ms(20)                      # her periyotta bir güncelleme / one update per period
N'alimente pas le servo par la broche 3V3 du Pico. Un SG90 peut tirer des pointes de plus de 500 mA en mouvement, ce qui fait redémarrer le Pico ou trembler le servo. Branche le fil rouge du servo sur le 5 V de l'USB (VBUS, broche physique 40) ou sur une alimentation 5 V externe, et le fil marron sur GND ; avec une alimentation externe, relie toujours les deux masses. Les détails sont dans Qu'est-ce qu'un servomoteur ?

Dans le projet dix-huit, tu pilotes un anneau de LED WS2812B avec le module neopixel intégré à MicroPython. Ces LED exigent un timing précis à la microseconde, et le Pico s'en charge sans occuper le processeur grâce à ses blocs d'entrées/sorties programmables, la PIO. On explique pas à pas comment utiliser la PIO et le second cœur dans PIO et double cœur du Pico. Un petit anneau de 8 à 12 LED peut être alimenté par VBUS ; les rubans plus longs demandent une alimentation 5 V séparée.

Niveau 5 : Wi-Fi et clavier USB avec le Pico W (19–20)

Dans le projet dix-neuf, le Pico W se connecte à ton réseau domestique et allume une LED depuis les boutons d'une page web que tu ouvres sur ton téléphone. Avec les modules network et socket de MicroPython, un serveur web fonctionnel tient en 40 à 50 lignes ; pour l'installation pas à pas, vois Serveur web Wi-Fi avec le Pico W. Dans le projet vingt, ton Pico se présente à l'ordinateur comme un clavier : attribue à chaque bouton un raccourci ou un texte et tu as ton propre pavé de macros. Ici le C/C++ est le plus simple, car le core Pico pour l'IDE Arduino fournit la bibliothèque Keyboard.

Le même projet en C/C++ : le Pico dans l'IDE Arduino

Une fois le paquet Raspberry Pi Pico/RP2040 d'Earle Philhower installé depuis le gestionnaire de cartes de l'IDE Arduino, tu programmes le Pico avec les commandes Arduino que tu connais déjà. Comme numéro de broche, tu utilises le numéro GP (14 pour GP14), analogWrite() travaille par défaut sur la plage 0–255 et attachInterrupt() fonctionne sur toutes les broches. Pour le premier téléversement, il faudra peut-être brancher le Pico en maintenant le bouton BOOTSEL. Le code ci-dessous réunit les projets 7 et 8 : la LED respire, s'arrête quand tu appuies sur le bouton et reprend au prochain appui.

C++ (Arduino IDE)
1// Arduino IDE + Raspberry Pi Pico (Earle Philhower çekirdeği / core)
2const int LED_PIN = 14;      // GP14 (fiziksel pin 19 / physical pin 19)
3const int BUTTON_PIN = 2;    // GP2, diğer ucu GND / other leg to GND
4
5volatile bool breathing = true;            // kesmede değişir / changed in the interrupt
6volatile unsigned long lastPress = 0;
7
8void onPress() {
9  unsigned long now = millis();
10  if (now - lastPress > 200) {             // 200 ms sıçrama filtresi / 200 ms debounce
11    breathing = !breathing;
12    lastPress = now;
13  }
14}
15
16void setup() {
17  pinMode(LED_PIN, OUTPUT);
18  pinMode(BUTTON_PIN, INPUT_PULLUP);
19  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onPress, FALLING);
20}
21
22void loop() {
23  if (!breathing) {                        // butonla durdurulduysa LED sönük / paused by the button
24    analogWrite(LED_PIN, 0);
25    return;
26  }
27  for (int v = 0; v <= 255; v++) { analogWrite(LED_PIN, v); delay(4); }   // yavaşça yan / fade in
28  for (int v = 255; v >= 0; v--) { analogWrite(LED_PIN, v); delay(4); }   // yavaşça sön / fade out
29}

Erreurs fréquentes et solutions

  • Mauvais numéro de broche : le code utilise le numéro GP, pas le numéro de broche physique. GP14 est la broche 19 de la carte ; tu trouves le brochage complet dans l'outil Pinout.
  • La LED intégrée ne s'allume pas sur le Pico W : sur le Pico W, la LED est reliée à la puce sans fil ; écris Pin("LED") au lieu de Pin(25).
  • Le code ne tourne plus une fois l'ordinateur débranché : enregistre le fichier sur le Pico sous le nom main.py ; c'est le seul fichier que le Pico lance tout seul au démarrage.
  • Le servo tremble ou le Pico redémarre : le servo est alimenté par le 3V3 ou les masses ne sont pas communes ; alimente-le en 5 V et ajoute un condensateur de 470 µF sur l'alimentation.
  • La valeur analogique reste à 0 ou à 65535 : le capteur est sur une autre broche que GP26–GP28, ou tu lis une patte extérieure du potentiomètre au lieu du curseur.
  • duty() des anciens exemples provoque une erreur : sur le Pico, le PWM de MicroPython utilise duty_u16() ou duty_ns().
  • Un appui est détecté plusieurs fois : c'est le rebond mécanique ; ajoute un filtre de 150 à 200 ms comme dans le code avec interruption.
Pour faire tourner un projet loin de l'ordinateur, alimente le Pico avec un chargeur USB de téléphone ou injecte 1,8 à 5,5 V sur la broche VSYS (par exemple 3 piles AA ou un seul accu Li-ion). N'oublie pas d'enregistrer d'abord ton code sous le nom main.py.

Une fois ces 20 projets terminés dans l'ordre, tu auras utilisé les entrées et sorties numériques, les interruptions, le PWM, l'ADC, l'I2C, la PIO et le Wi-Fi du Pico, soit presque tout ce qu'il faut pour concevoir tes propres projets. Pour être plus à l'aise en MicroPython, Les bases de MicroPython est une bonne étape suivante. Dans l'application BlueGrays, tu peux essayer pas à pas des projets Pico comme la LED intégrée, le feu tricolore, le gyrophare, le chenillard K2000, l'interruption de bouton, la LED qui respire en PWM et le cycle de couleurs RGB, chacun avec son schéma de câblage et son code.

Questions fréquentes

Que peut-on faire avec un Raspberry Pi Pico ?

Tu peux réaliser des effets lumineux à LED, des appareils de mesure à capteurs, des thermomètres à écran OLED, des commandes de servos et de moteurs, des claviers USB et des manettes de jeu, et avec un Pico W des projets domotiques pilotés depuis ton téléphone. Le Pico est un microcontrôleur et non un ordinateur : il ne sert pas à lire des vidéos ni à faire tourner des logiciels de bureau.

Le Raspberry Pi Pico est-il adapté aux débutants ?

Oui. Avec MicroPython, tu réutilises directement tes connaissances en Python et tu exécutes ton code sans compilation. Le point principal à surveiller, c'est que les broches fonctionnent en 3,3 V : les capteurs à sortie 5 V se branchent via un pont diviseur ou un convertisseur de niveau.

Faut-il apprendre MicroPython ou le C++ pour le Pico ?

Si la programmation et l'électronique sont nouvelles pour toi, commence par MicroPython : les messages d'erreur sont compréhensibles et tu testes plus vite. Passe au C/C++ quand tu as besoin d'un timing précis, de plus de vitesse ou d'une bibliothèque qui n'existe que pour Arduino ; le Pico accepte les deux.

Le Raspberry Pi Pico peut-il piloter un servo directement ?

Côté signal, oui : n'importe quelle broche GPIO commande un servo comme le SG90 avec un PWM à 50 Hz. L'alimentation du servo doit en revanche venir de VBUS ou d'une alimentation 5 V externe, pas de la broche 3V3, et les masses doivent être reliées.

Quelle est la différence entre le Pico et le Pico W ?

Les deux utilisent la même puce RP2040 ; le Pico W ajoute une puce Wi-Fi 2,4 GHz et Bluetooth. Tous les projets sans Wi-Fi fonctionnent sur les deux, la seule différence étant que la LED intégrée du Pico W se commande avec Pin("LED").

Peut-on utiliser du code Arduino sur un Raspberry Pi Pico ?

En installant le paquet RP2040 d'Earle Philhower dans l'IDE Arduino, la plupart des croquis fonctionnent avec de petites modifications, en utilisant les numéros GP comme numéros de broche. Le code qui touche aux registres propres aux AVR ou les montages qui supposent une logique 5 V doivent être adaptés.

Voir tous les projets
Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
PI-1Débutant

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.

5.0(1)
10
Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
PI-2Débutant

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.

4.5(2)
7
Simulateur de Feu de Circulation Raspberry Pi Pico (3 LEDs séquentielles)
PI-4Débutant

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Ω.

4.0(1)
12
Raspberry Pi Pico Effet Gyrophare Police (Rouge + Bleu Stroboscope)
PI-5Débutant

Raspberry Pi Pico Effet Gyrophare Police (Rouge + Bleu Stroboscope)

Nous simulons la rampe lumineuse d'une voiture de police avec un Raspberry Pi Pico, dans sa version la plus simple ! Les LED rouge et bleue s'allument à tour de rôle (flip-flop) : quand la rouge est allumée, la bleue est éteinte, et elles s'échangent toutes les 0,3 seconde, sans fin. Le code écrit les deux étapes directement dans une seule boucle while True ; la vitesse se règle avec la constante WAIT_MS.

4.7(3)
10
Raspberry Pi Pico Knight Rider LED Scanner (6 LED Aller-Retour)
PI-8Débutant

Raspberry Pi Pico Knight Rider LED Scanner (6 LED Aller-Retour)

Effet scanner LED "Knight Rider" classique avec Pico ! 6 LEDs vont de gauche à droite, puis de droite à gauche, à l'infini. Apprends reversed() et deux boucles for séparées pour motif aller-retour.

5.0(1)
14
Raspberry Pi Pico Bouton Debounce : IRQ vs Software Polling
PI-13Intermédiaire
Premium

Raspberry Pi Pico Bouton Debounce : IRQ vs Software Polling

Une pression, le code compte 3-4 ? C'est le contact bounce ! Compare 2 méthodes de comptage dans Serial : RAW polling (attrape bounce, compte faux) vs IRQ + software debounce (précis). Apprends physique du bounce, software debounce, Pin.irq() interrupt, IRQ_FALLING trigger, ISR handlers, sécurité des variables globales ISR.

12
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

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.

4
Raspberry Pi Pico LED RVB Cycle de Couleurs (PWM 3 Canaux)
PI-15Débutant

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.

6