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.

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 :
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éristique | Pull-up | Pull-down |
|---|---|---|
| Où est la résistance ? | Entre la broche et VCC | Entre la broche et GND |
| Où est le bouton ? | Entre la broche et GND | Entre la broche et VCC |
| Bouton relâché | HIGH (1) | LOW (0) |
| Bouton appuyé | LOW (0) | HIGH (1) |
| Type de logique | Actif bas | Actif haut |
| Support interne | Uno, ESP32, Pico | ESP32, Pico |
| Usage typique | Bouton, I2C, ligne reset | Grille de MOSFET, sorties de capteurs |
Pull-up et pull-down internes : Arduino Uno, ESP32 et Pico
| Caractéristique | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Niveau logique | 5 V | 3,3 V | 3,3 V |
| Pull-up interne | Oui, 20–50 kΩ | Oui, environ 45 kΩ | Oui, 50–80 kΩ |
| Pull-down interne | Non | Oui, environ 45 kΩ | Oui, 50–80 kΩ (problème sur Pico 2) |
| Activation dans le code | INPUT_PULLUP | INPUT_PULLUP / INPUT_PULLDOWN | Pin.PULL_UP / Pin.PULL_DOWN |
| Bouton pull-up (broche – GND) | D2 | GPIO 18 | GP2 |
| Bouton pull-down (broche – VCC) | D3 + 10 kΩ externe | GPIO 19 (vers 3V3) | GP3 (vers 3V3) |
| Broches sans résistance interne | Aucune | GPIO 34–39 | Aucune |
| Broches I2C (SDA / SCL) | A4 / A5 | GPIO 21 / GPIO 22 | GP4 / GP5 |
Utiliser INPUT_PULLUP sur Arduino pas à pas
- 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.
- Relie une patte du second bouton à D3 et la patte opposée en diagonale à 5V.
- Place une résistance pull-down externe de 10 kΩ entre D3 et GND (bagues marron-noir-orange).
- Téléverse le code, ouvre le moniteur série à 9600 bauds et appuie sur les deux boutons l'un après l'autre.
- 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.
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.
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.
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.
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)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.
| Application | Valeur conseillée | Raison |
|---|---|---|
| Bouton, interrupteur, relais reed | 10 kΩ (ou interne) | 0,5 mA sous 5 V, rappel assez fort |
| Bouton avec câble de plus d'1 m | 1–4,7 kΩ | Rappel plus ferme contre le bruit |
| Appareil sur batterie | 47–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 kHz | 4,7 kΩ | Le temps de montée reste sous la limite de 1000 ns |
| I2C, 400 kHz | 2,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.
| Mode | Vitesse | Temps de montée max. | Pull-up typique (3,3 V) |
|---|---|---|---|
| Mode standard | 100 kHz | 1000 ns | 4,7–10 kΩ |
| Mode rapide (Fast-mode) | 400 kHz | 300 ns | 2,2–4,7 kΩ |
| Fast-mode Plus | 1 MHz | 120 ns | 1–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ôme | Cause probable | Solution |
|---|---|---|
| La LED clignote sans appui sur le bouton | Broche flottante, pas de résistance de rappel | Utilise INPUT_PULLUP ou ajoute une résistance externe de 10 kΩ |
| La valeur lue change quand tu approches la main | Entrée flottante, le long câble fait antenne | Diminue la résistance de rappel (4,7 kΩ), raccourcis le câble |
| Le bouton semble toujours appuyé | Logique pull-up interprétée à l'envers | Considère LOW comme appuyé ou utilise !digitalRead |
| À l'appui, la broche reste entre 1 et 2 V | Pull-up interne et pull-down externe actifs en même temps | N'utilise que l'un des deux ; mets pinMode en INPUT |
| INPUT_PULLUP ne marche pas sur le GPIO 35 de l'ESP32 | Pas de résistance interne sur GPIO 34–39 | Ajoute un pull-up externe de 10 kΩ |
| L'ESP32 ne démarre pas ou redémarre sans cesse | Pull-up sur GPIO 12 ou pull-down sur GPIO 0 | Déplace le bouton sur un GPIO qui n'est pas une broche de démarrage |
| Le composant I2C est introuvable ou Wire se bloque | Pas de pull-up, ou trop de résistances de modules en parallèle | Ajoute 4,7 kΩ ou retire les résistances des modules en trop |
| Les broches I2C de l'ESP32 ou du Pico sont endommagées | Pull-up reliés à 5 V | Relie les pull-up à 3,3 V, utilise un convertisseur de niveau logique si besoin |
| Plusieurs comptages pour un seul appui | Rebonds du bouton (debounce), sans rapport avec le pull | Applique un debounce logiciel de 20–50 ms |
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.
Projets à réaliser après cet article
Voir tous les projets
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.

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.

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.

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.

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

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 ?
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

