Bases · 11 min de lecture

Résistance pull-up : pull-down, INPUT_PULLUP et choix de valeur

Résistance pull-up et pull-down : pourquoi une entrée flottante pose problème ? INPUT_PULLUP, résistances internes ESP32 et Pico, pull-up I2C et valeur de 10k.

Une résistance pull-up est une résistance, généralement de 10 kΩ, qui relie une entrée de microcontrôleur à la tension d'alimentation (VCC) quand elle n'est pas utilisée, pour garder la broche à un niveau HIGH stable. Une résistance pull-down fait l'inverse : elle tire la broche vers la masse (GND) et la maintient à LOW. Quand tu branches un bouton, un interrupteur ou un relais reed sur Arduino, ce sont ces petites résistances qui évitent que la valeur lue saute au hasard. Sur la plupart des cartes, elle existe déjà dans la puce ; sur Arduino, écrire INPUT_PULLUP suffit pour l'activer.

Dans cet article, tu vas voir pas à pas pourquoi une entrée flottante (floating) produit des valeurs aléatoires, la différence entre pull-up et pull-down, les résistances internes de l'Arduino Uno, de l'ESP32 et du Raspberry Pi Pico, comment calculer la bonne valeur, et pourquoi le bus I2C ne fonctionne pas sans pull-up. Chaque section contient de vraies mesures, des formules et du code à téléverser directement.

Résistances traversantes utilisées comme pull-up et pull-down
Résistances traversantes : la valeur la plus courante pour les boutons en pull-up et pull-down est 10 kΩ (marron-noir-orange).

Qu'est-ce qu'une entrée flottante et pourquoi pose-t-elle problème ?

Une broche d'entrée numérique est une porte à très haute impédance (de l'ordre de centaines de mégaohms) qui ne fait que détecter la tension et ne consomme presque aucun courant. Si rien n'est relié à cette broche, ou si le bouton ouvert la laisse déconnectée, sa tension reste indéfinie. On parle d'entrée flottante (floating). Une telle broche se comporte comme une mini-antenne : elle subit l'influence des fils voisins, du champ de 50 Hz du secteur, et même de ta main qui s'approche, et la valeur lue oscille entre 0 et 1 des dizaines de fois par seconde.

Pour comprendre, regardons les seuils logiques. Alimentée en 5 V, la puce ATmega328P de l'Arduino Uno considère comme HIGH sûr tout ce qui dépasse 3 V (60 % de VCC) et comme LOW sûr tout ce qui est sous 1,5 V (30 % de VCC). La zone intermédiaire est indéterminée, et une broche flottante traîne souvent justement là. Résultat : une LED qui s'allume sans appui, un compteur qui augmente au hasard ou une interruption qui se déclenche sans arrêt. Pour le voir toi-même, branche un simple fil volant sur D2 sans bouton, téléverse le code ci-dessous et touche l'extrémité du fil avec le moniteur série ouvert :

C++ (Arduino IDE)
1void setup() {
2  Serial.begin(9600);
3  pinMode(2, INPUT);                // pull direnci yok, pin havada / no pull resistor, pin is floating
4}
5
6void loop() {
7  Serial.println(digitalRead(2));   // rastgele 0 ve 1 görürsün / you will see random 0s and 1s
8  delay(100);
9}

Qu'est-ce qu'une résistance pull-up et pull-down, et comment ça marche ?

Dans un montage pull-up, une extrémité de la résistance va à la broche d'entrée et l'autre à VCC ; le bouton est placé entre la broche et GND. Bouton ouvert, presque aucun courant ne circule, donc il n'y a pas de chute de tension dans la résistance et la broche voit VCC, soit HIGH. Quand tu appuies, la broche est reliée directement à GND et tu lis LOW. Un petit courant traverse alors la résistance : d'après la loi d'Ohm, I = V / R, soit 0,5 mA avec 5 V et 10 kΩ. Si tu avais relié la broche directement à VCC, appuyer court-circuiterait l'alimentation ; la résistance tire la broche vers le haut et évite ce court-circuit. Pour d'autres valeurs, tu peux calculer le courant rapidement avec le calculateur de loi d'Ohm.

Le montage pull-down en est le miroir : la résistance est placée entre la broche et GND, le bouton entre la broche et VCC. Bouton ouvert, la broche est tirée à la masse par la résistance et tu lis LOW ; à l'appui, elle est reliée à VCC et tu lis HIGH. Cette logique semble plus naturelle aux débutants : appuyer donne 1, relâcher donne 0. Mais la puce de l'Arduino Uno n'a pas de pull-down interne ; sur Uno, il te faut une résistance externe de 10 kΩ. L'ESP32 et le Raspberry Pi Pico intègrent les deux types.

CaractéristiquePull-upPull-down
Où est la résistance ?Entre la broche et VCCEntre la broche et GND
Où est le bouton ?Entre la broche et GNDEntre la broche et VCC
Bouton relâchéHIGH (1)LOW (0)
Bouton appuyéLOW (0)HIGH (1)
Type de logiqueActif basActif haut
Support interneUno, ESP32, PicoESP32, Pico
Usage typiqueBouton, I2C, ligne resetGrille de MOSFET, sorties de capteurs

Pull-up et pull-down internes : Arduino Uno, ESP32 et Pico

CaractéristiqueArduino UnoESP32Raspberry Pi Pico
Niveau logique5 V3,3 V3,3 V
Pull-up interneOui, 20–50 kΩOui, environ 45 kΩOui, 50–80 kΩ
Pull-down interneNonOui, environ 45 kΩOui, 50–80 kΩ (problème sur Pico 2)
Activation dans le codeINPUT_PULLUPINPUT_PULLUP / INPUT_PULLDOWNPin.PULL_UP / Pin.PULL_DOWN
Bouton pull-up (broche – GND)D2GPIO 18GP2
Bouton pull-down (broche – VCC)D3 + 10 kΩ externeGPIO 19 (vers 3V3)GP3 (vers 3V3)
Broches sans résistance interneAucuneGPIO 34–39Aucune
Broches I2C (SDA / SCL)A4 / A5GPIO 21 / GPIO 22GP4 / GP5
Sur l'ESP32, les GPIO 34–39 sont uniquement des entrées et n'ont ni pull-up ni pull-down internes ; écrire INPUT_PULLUP sur ces broches ne change rien, une résistance externe de 10 kΩ est indispensable. Fais aussi attention aux broches de démarrage (strapping) : un pull-up qui maintient GPIO 12 à HIGH au démarrage règle la tension de la flash à 1,8 V et peut empêcher la carte de démarrer, et un pull-down qui force GPIO 0 à LOW met la carte en mode programmation.

Utiliser INPUT_PULLUP sur Arduino pas à pas

  1. Relie une patte du premier bouton à D2 et la patte opposée en diagonale à GND ; ce bouton n'a pas besoin de résistance, on utilise le pull-up interne.
  2. Relie une patte du second bouton à D3 et la patte opposée en diagonale à 5V.
  3. Place une résistance pull-down externe de 10 kΩ entre D3 et GND (bagues marron-noir-orange).
  4. Téléverse le code, ouvre le moniteur série à 9600 bauds et appuie sur les deux boutons l'un après l'autre.
  5. Vérifie que les boutons relâchés affichent 0 et les boutons appuyés 1 ; la LED intégrée de D13 s'allume dès qu'on appuie sur l'un des deux.
C++ (Arduino IDE)
1const int BTN_PULLUP = 2;     // buton D2 - GND, dahili pull-up / button D2 - GND, internal pull-up
2const int BTN_PULLDOWN = 3;   // buton D3 - 5V, harici 10k D3 - GND / button D3 - 5V, external 10k D3 - GND
3const int LED_PIN = 13;       // dahili LED / built-in LED
4
5void setup() {
6  Serial.begin(9600);
7  pinMode(BTN_PULLUP, INPUT_PULLUP);   // dahili pull-up açık / internal pull-up enabled
8  pinMode(BTN_PULLDOWN, INPUT);        // Uno'da dahili pull-down yok / Uno has no internal pull-down
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  bool a = (digitalRead(BTN_PULLUP) == LOW);     // pull-up: basınca LOW / pull-up: LOW when pressed
14  bool b = (digitalRead(BTN_PULLDOWN) == HIGH);  // pull-down: basınca HIGH / pull-down: HIGH when pressed
15  digitalWrite(LED_PIN, (a || b) ? HIGH : LOW);
16  Serial.print(a ? 1 : 0);
17  Serial.print(' ');
18  Serial.println(b ? 1 : 0);
19  delay(50);
20}

La ligne pinMode(BTN_PULLUP, INPUT_PULLUP) active la résistance interne de 20–50 kΩ ; D2 lit donc HIGH au repos et LOW à l'appui. D3 est réglée en INPUT classique, car c'est la résistance externe de 10 kΩ qui la tire vers le bas. Dans le code, on utilise une comparaison pour donner le même sens aux deux logiques : le bouton pull-up est considéré appuyé quand il vaut LOW, le bouton pull-down quand il vaut HIGH. Le schéma pinMode(pin, INPUT) suivi de digitalWrite(pin, HIGH) que tu vois dans les anciens codes Arduino active le même pull-up interne ; INPUT_PULLUP en est la version plus lisible.

Les entrées avec pull-up s'appellent actif bas (active low). Pour garder ton code lisible, inverse la logique dès le départ avec une ligne comme bool appuye = !digitalRead(pin); ; ainsi, dans le reste du programme, un bouton appuyé vaut toujours true. Pour gérer aussi les rebonds (debounce), consulte l'article Comment brancher un bouton à Arduino.

INPUT_PULLUP et INPUT_PULLDOWN sur ESP32

Presque chaque GPIO de l'ESP32 possède un pull-up et un pull-down internes d'environ 45 kΩ. Dans le core Arduino, tu les actives avec les constantes INPUT_PULLUP et INPUT_PULLDOWN, identiques dans les versions 2.x et 3.x du core ESP32 Arduino. Comme l'ESP32 fonctionne en 3,3 V, l'autre extrémité du bouton pull-down doit aller sur la broche 3V3 et non sur 5V ; les GPIO ne tolèrent pas 5 V. Dans l'exemple ci-dessous, le bouton du GPIO 18 va à GND et celui du GPIO 19 à 3V3, sans aucune résistance externe.

C++ (Arduino IDE)
1const int BTN_PULLUP = 18;     // buton GPIO18 - GND / button GPIO18 - GND
2const int BTN_PULLDOWN = 19;   // buton GPIO19 - 3V3 / button GPIO19 - 3V3
3const int LED_PIN = 2;         // çoğu kartta dahili LED / built-in LED on most boards
4
5void setup() {
6  Serial.begin(115200);
7  pinMode(BTN_PULLUP, INPUT_PULLUP);       // dahili pull-up / internal pull-up
8  pinMode(BTN_PULLDOWN, INPUT_PULLDOWN);   // dahili pull-down / internal pull-down
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  bool a = (digitalRead(BTN_PULLUP) == LOW);     // pull-up: basınca LOW / pull-up: LOW when pressed
14  bool b = (digitalRead(BTN_PULLDOWN) == HIGH);  // pull-down: basınca HIGH / pull-down: HIGH when pressed
15  digitalWrite(LED_PIN, (a || b) ? HIGH : LOW);
16  Serial.print(a ? 1 : 0);
17  Serial.print(' ');
18  Serial.println(b ? 1 : 0);
19  delay(50);
20}

Pin.PULL_UP et Pin.PULL_DOWN sur Raspberry Pi Pico

Le RP2040 du Raspberry Pi Pico dispose pour chaque GPIO d'un pull-up et d'un pull-down internes d'environ 50–80 kΩ. En MicroPython, il suffit de passer Pin.PULL_UP ou Pin.PULL_DOWN comme troisième paramètre à la création de l'objet Pin. Dans le code ci-dessous, le bouton de GP2 va à GND et celui de GP3 à 3V3 ; la LED de la carte s'allume quand on appuie sur l'un d'eux.

MicroPython
1from machine import Pin
2import time
3
4btn_up = Pin(2, Pin.IN, Pin.PULL_UP)       # buton GP2 - GND / button GP2 - GND
5btn_down = Pin(3, Pin.IN, Pin.PULL_DOWN)   # buton GP3 - 3V3 / button GP3 - 3V3
6led = Pin(25, Pin.OUT)                     # dahili LED, Pico W'de LED adini kullan / onboard LED, use the LED name on Pico W
7
8while True:
9    a = btn_up.value() == 0       # pull-up: basinca 0 / pull-up: 0 when pressed
10    b = btn_down.value() == 1     # pull-down: basinca 1 / pull-down: 1 when pressed
11    led.value(1 if (a or b) else 0)
12    time.sleep_ms(20)
Si tu utilises un Pico 2, attention : à cause d'un défaut matériel connu sous le nom E9 dans la révision A2 de la puce RP2350, le pull-down interne seul n'est pas fiable ; la broche peut rester bloquée vers 2 V quand on la laisse libre et le bouton semble toujours appuyé. Sur cette carte, préfère un montage pull-up ou utilise un pull-down externe de 8,2 kΩ ou moins (par ex. 4,7 kΩ).

Comment choisir la valeur d'une résistance pull-up ?

Plus la résistance de rappel est petite, plus elle tire fort sur la broche, mais plus elle consomme de courant à l'appui. Plus elle est grande, moins elle consomme, mais plus la broche est sensible au bruit et plus les changements de tension sont lents. La formule du courant est simple : I = VCC / R. Sous 5 V, 1 kΩ donne 5 mA par bouton appuyé, 10 kΩ donne 0,5 mA et 100 kΩ seulement 0,05 mA, soit 50 µA. Sur un appareil sur batterie dont le bouton peut rester appuyé longtemps, cette différence influence directement l'autonomie.

Deux facteurs fixent la limite haute. Le premier est le courant de fuite : une entrée de l'ATmega328P fuit au maximum environ 1 µA ; sur un pull-up de 100 kΩ, cela ne crée qu'une chute de 0,1 V et ne pose pas de problème, mais à 1 MΩ la chute atteint 1 V et la broche se rapproche du seuil. Le second est la vitesse : la résistance forme avec la capacité de la broche et du câble un circuit RC dont la constante de temps est τ = R × C. Avec 10 kΩ et un câble de 100 pF, τ = 1 µs, bien assez rapide pour un bouton. Règle générale : 10 kΩ pour les boutons, 1–4,7 kΩ pour les câbles longs et bruyants, 47–100 kΩ là où il faut économiser la batterie. Pour déchiffrer les bagues de couleur, utilise l'outil de code couleur des résistances.

ApplicationValeur conseilléeRaison
Bouton, interrupteur, relais reed10 kΩ (ou interne)0,5 mA sous 5 V, rappel assez fort
Bouton avec câble de plus d'1 m1–4,7 kΩRappel plus ferme contre le bruit
Appareil sur batterie47–100 kΩSeulement 50–100 µA à l'appui
Grille de MOSFET (pull-down)10–100 kΩEmpêche le moteur de démarrer seul à la mise sous tension
I2C, 100 kHz4,7 kΩLe temps de montée reste sous la limite de 1000 ns
I2C, 400 kHz2,2 kΩValeur plus faible pour respecter la limite de 300 ns

Les résistances pull-up sur le bus I2C

Sur le bus I2C, la résistance pull-up n'est pas une option mais une obligation. Les composants reliés à SDA et SCL utilisent une sortie à drain ouvert (open-drain) : ils peuvent seulement tirer la ligne vers GND, pas la porter à HIGH. Ce sont uniquement les résistances pull-up qui ramènent la ligne à HIGH. Ainsi, même si deux composants essaient de parler en même temps, il n'y a pas de court-circuit : quand l'un tire la ligne à LOW, l'autre ne fait que le constater. Sans pull-up, le scanner I2C ne trouve aucun composant ou le programme reste bloqué dans les fonctions Wire. Pour les détails du protocole, consulte l'article Qu'est-ce que l'I2C.

Sur Arduino Uno, la bibliothèque Wire active les pull-up internes au démarrage ; mais 20–50 kΩ est faible pour l'I2C et ne fonctionne par chance qu'avec des câbles courts. Heureusement, la plupart des modules prêts à l'emploi comme l'OLED, le BME280 ou l'écran LCD I2C ont déjà des pull-up de 4,7 kΩ ou 10 kΩ soudés sur la carte. Un point souvent oublié est la mise en parallèle : si tu branches sur la même ligne trois modules portant chacun un pull-up de 10 kΩ, la résistance équivalente tombe à 3,3 kΩ, et à 1,7 kΩ avec six modules, ce qui rend plus difficile pour les composants de tirer la ligne à LOW. Pour le calcul, la résistance minimale est Rmin = (VCC − 0,4 V) / 3 mA, soit environ 1 kΩ sous 3,3 V ; la maximale se trouve avec Rmax = tr / (0,8473 × Cb). À 400 kHz (tr = 300 ns) et une capacité de ligne de 100 pF, Rmax vaut environ 3,5 kΩ. Tu trouveras facilement les valeurs en parallèle avec le calculateur de résistances série-parallèle.

ModeVitesseTemps de montée max.Pull-up typique (3,3 V)
Mode standard100 kHz1000 ns4,7–10 kΩ
Mode rapide (Fast-mode)400 kHz300 ns2,2–4,7 kΩ
Fast-mode Plus1 MHz120 ns1–1,5 kΩ

Où as-tu besoin d'une résistance de rappel ? Idées de projets

  • Lecture de boutons et d'interrupteurs : chaque bouton a besoin d'une résistance de rappel ; avec le debounce, c'est expliqué dans le guide de branchement d'un bouton.
  • Capteur de porte et de fenêtre : le relais reed est un interrupteur qui se ferme quand un aimant approche ; avec INPUT_PULLUP, il se lit avec un seul fil.
  • Serrure à code : la bibliothèque Keypad utilise les pull-up internes sur les broches de lignes, donc le clavier 4x4 n'exige aucune résistance supplémentaire.
  • Pilotage de moteur et de ruban LED : un pull-down de 10 kΩ sur la grille d'un MOSFET empêche le moteur de tourner pendant que l'Arduino démarre et que la broche n'est pas encore configurée.
  • Réaction immédiate par interruption : les broches d'interruption flottantes se déclenchent en continu ; avec un pull-up, elles deviennent stables.
  • Encodeur rotatif : les sorties d'un encodeur rotatif se lisent avec un pull-up ; sur un encodeur nu sans module, tu dois activer le pull-up interne.
  • Bus de capteurs et d'écrans : en regroupant des modules I2C comme l'OLED, le BME280 et le RTC sur la même ligne, calcule la valeur totale des pull-up.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
La LED clignote sans appui sur le boutonBroche flottante, pas de résistance de rappelUtilise INPUT_PULLUP ou ajoute une résistance externe de 10 kΩ
La valeur lue change quand tu approches la mainEntrée flottante, le long câble fait antenneDiminue la résistance de rappel (4,7 kΩ), raccourcis le câble
Le bouton semble toujours appuyéLogique pull-up interprétée à l'enversConsidère LOW comme appuyé ou utilise !digitalRead
À l'appui, la broche reste entre 1 et 2 VPull-up interne et pull-down externe actifs en même tempsN'utilise que l'un des deux ; mets pinMode en INPUT
INPUT_PULLUP ne marche pas sur le GPIO 35 de l'ESP32Pas de résistance interne sur GPIO 34–39Ajoute un pull-up externe de 10 kΩ
L'ESP32 ne démarre pas ou redémarre sans cessePull-up sur GPIO 12 ou pull-down sur GPIO 0Déplace le bouton sur un GPIO qui n'est pas une broche de démarrage
Le composant I2C est introuvable ou Wire se bloquePas de pull-up, ou trop de résistances de modules en parallèleAjoute 4,7 kΩ ou retire les résistances des modules en trop
Les broches I2C de l'ESP32 ou du Pico sont endommagéesPull-up reliés à 5 VRelie les pull-up à 3,3 V, utilise un convertisseur de niveau logique si besoin
Plusieurs comptages pour un seul appuiRebonds du bouton (debounce), sans rapport avec le pullApplique un debounce logiciel de 20–50 ms
Si tu relies une résistance pull-down externe à une broche dont le pull-up interne est actif, les deux résistances forment un diviseur de tension. Par exemple, sur Uno, un pull-up interne de 35 kΩ avec un pull-down externe de 10 kΩ maintient la broche à 5 × 10 / 45 ≈ 1,1 V ; cette valeur est dangereusement proche de la limite LOW (1,5 V). Garde une seule résistance de rappel par broche : soit à l'intérieur, soit à l'extérieur.

Les résistances pull-up et pull-down sont petites mais comptent parmi les briques les plus utilisées en électronique ; une fois leur logique comprise, les boutons, les capteurs et les lignes I2C ne te réservent plus de surprises. Pour consolider ce que tu as appris, regarde dans l'application BlueGrays les projets d'allumage de LED avec bouton, de contrôle de bouton sur ESP32 et de comparaison de debounce sur Pico ; chacun propose un schéma pas à pas et du code prêt à l'emploi.

Questions fréquentes

Quelle valeur de résistance pull-up choisir ?

Pour les boutons et interrupteurs, la valeur la plus courante est 10 kΩ ; elle ne consomme que 0,5 mA à l'appui sous 5 V et résiste bien au bruit. Avec de longs câbles, tu peux descendre à 4,7 kΩ ; sur batterie, monter à 47–100 kΩ. Sur un bus I2C, on prend 4,7 kΩ à 100 kHz et 2,2 kΩ à 400 kHz.

Quelle différence entre INPUT et INPUT_PULLUP ?

En mode INPUT, la broche lit seulement la tension et n'est tirée dans aucune direction ; sans résistance externe, elle reste flottante. INPUT_PULLUP active la résistance interne de 20–50 kΩ et relie la broche à VCC. Il te suffit alors de brancher le bouton entre la broche et GND et de lire LOW à l'appui.

L'Arduino Uno a-t-il une résistance pull-down interne ?

Non, les puces AVR de l'Uno, du Nano et du Mega n'ont qu'un pull-up interne, et la constante INPUT_PULLDOWN n'est pas définie sur ces cartes. Si tu as besoin d'un pull-down, relie une résistance externe de 10 kΩ entre la broche et GND. L'ESP32 et le Raspberry Pi Pico gèrent en revanche le pull-down interne.

Les résistances pull-up sont-elles nécessaires pour l'I2C ?

Oui, comme les composants I2C ne peuvent que tirer les lignes à LOW, les pull-up qui ramènent SDA et SCL à HIGH sont indispensables. La plupart des modules ont déjà des résistances de 4,7 kΩ ou 10 kΩ sur la carte, donc avec un seul module aucune résistance supplémentaire n'est nécessaire. Avec une puce de capteur nue ou une ligne longue, ajoute 4,7 kΩ sur chaque ligne.

Faut-il utiliser un pull-up ou un pull-down ?

Dans la plupart des cas, le pull-up est plus pratique : il existe en interne sur toutes les cartes, et relier le bouton à GND est plus sûr que de faire circuler l'alimentation par un fil. Le pull-down se choisit quand tu veux lire 1 à l'appui, ou sur des lignes comme la grille d'un MOSFET qui doivent rester à LOW au démarrage. Quel que soit ton choix, il suffit d'adapter la logique dans ton code.

Que se passe-t-il si on branche un bouton sans résistance pull-up ?

Bouton ouvert, la broche n'est reliée à rien : elle flotte et capte le bruit électrique ambiant. digitalRead renvoie alors des 0 et des 1 aléatoires, la LED clignote seule ou l'interruption se déclenche en continu. Pour régler le problème, il te suffit d'utiliser INPUT_PULLUP ou d'ajouter une résistance externe.

Voir tous les projets
Allumer une LED avec un bouton-poussoir (Push)
AR-9Débutant

Allumer une LED avec un bouton-poussoir (Push)

Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

4.8(114)
253
Allumer et éteindre une LED avec un bouton
AR-10Débutant

Allumer et éteindre une LED avec un bouton

Un appui et la lumière s'allume, un deuxième et elle s'éteint, exactement comme l'interrupteur de ta chambre.

4.7(103)
177
ESP32 Contrôle de LED avec bouton poussoir (Push)
ES-2Débutant

ESP32 Contrôle de LED avec bouton poussoir (Push)

La LED s'allume lorsque le bouton est enfoncé et s'éteint lorsqu'il est relâché. Montre comment la broche d'entrée numérique de l'ESP32 et la résistance pull-up interne sont utilisées. Grâce au mode INPUT_PULLUP, aucune résistance externe n'est nécessaire.

4.6(36)
57
ESP32 Contrôle de LED avec bouton (Toggle)
ES-3Débutant

ESP32 Contrôle de LED avec bouton (Toggle)

Chaque fois que l'on appuie sur le bouton, la LED change d'état : si elle est allumée, elle s'éteint, si elle est éteinte, elle s'allume. Modèle classique de basculement. Avec le debounce, nous nettoyons le bruit mécanique du bouton-poussoir pour garantir un seul basculement avec une seule pression.

4.6(39)
59
Raspberry Pi Pico LED Contrôlée par Bouton (Push)
PI-9Débutant
Premium

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.

11
Raspberry Pi Pico Bouton Toggle LED
PI-10Débutant

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.

10
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
Lecture d'un interrupteur reed
AR-37Débutant

Lecture d'un interrupteur reed

Tu t'es déjà demandé comment marche l'interrupteur magnétique des alarmes de portes et de fenêtres ?

4.5(22)
29