Comment utiliser une breadboard : rails et première LED
Comment utiliser une breadboard ? Rails, colonnes de 5 trous, canal central, premier circuit LED avec résistance, placement ESP32 et Pico, erreurs courantes.
La réponse courte à la question « comment utiliser une breadboard » : sous le boîtier en plastique, des bandes métalliques relient entre eux certains trous. Tu branches les broches qui doivent être reliées sur la même bande, et celles qui ne doivent pas l'être sur des bandes différentes : tu montes ainsi un circuit sans soudure. Dans chaque colonne numérotée, les groupes de cinq trous (a–e et f–j) sont reliés entre eux, le canal central sépare la plaque en deux moitiés indépendantes, et les longs rails d'alimentation sur les bords transportent le + et le − d'un bout à l'autre de la plaque. Une fois ces trois règles comprises, toutes tes expériences avec Arduino, ESP32 ou Raspberry Pi Pico iront bien plus vite et avec moins d'erreurs.
Dans ce guide, on va examiner l'intérieur de la breadboard trou par trou, allumer d'abord une LED sans écrire une ligne de code, puis la faire clignoter avec Arduino. Ensuite tu verras comment placer l'ESP32, qui pose problème avec son boîtier large, et le Raspberry Pi Pico, qui s'enfiche presque parfaitement, comment garder tes câbles jumper bien rangés et quelles petites erreurs font perdre des heures aux débutants.

Qu'est-ce qu'une breadboard et comment fonctionne-t-elle ?
La breadboard (ou platine d'essai, plaque de prototypage) est un support d'expérimentation réutilisable. Sous chaque trou se trouve un clip métallique à ressort : quand tu enfonces la patte d'une résistance ou l'extrémité d'un câble jumper, le clip serre le fil des deux côtés et assure le contact électrique. L'écartement entre les trous est de 2,54 mm (0,1 pouce), si bien que les circuits intégrés, barrettes de broches, boutons et la plupart des modules s'y enfichent directement. Les clips acceptent sans problème des fils rigides de 20 à 29 AWG (environ 0,3 à 0,8 mm de diamètre) ; le fil idéal est un fil monobrin de 22 AWG.
| Type | Nombre de trous | Rail d'alimentation | Pour quoi faire ? |
|---|---|---|---|
| Mini breadboard | 170 (17 colonnes × 10) | Aucun | Un seul capteur, tests de petits modules |
| Demi-format (half-size) | 400 (300 + 100 de rails) | 2 paires, 25 trous chacune | Projets de débutant, Pico et Nano |
| Format complet (full-size) | 830 (630 + 200 de rails) | 2 paires, 50 trous chacune | Projets avec beaucoup de composants, ESP32 |
| Kits assemblables | Selon le module | Rails détachables | Grands prototypes, deux cartes côte à côte |
Structure interne : rails d'alimentation, colonnes et canal central
Place la breadboard devant toi, le grand côté à l'horizontale. Les numéros 1, 2, 3… sur le bord indiquent les colonnes, et les lettres de a à j indiquent les rangées. Dans une même colonne, les trous a, b, c, d, e sont reliés par une seule bande métallique ; les trous f, g, h, i, j de cette colonne sont reliés par une autre bande. Une patte placée en 12a est donc au même point qu'une patte en 12c, mais n'a aucun lien avec 13a ni avec 12f. Si tu mets les deux pattes d'un composant dans le même groupe de cinq, tu le court-circuites : le courant passe par la bande métallique et non par le composant.
Le large espace entre e et f s'appelle le canal central et mesure exactement 7,62 mm (0,3 pouce). Cette cote est voulue : les circuits intégrés en boîtier DIP (555, 74HC595, L293D…) s'y posent à cheval, de sorte que chaque broche tombe dans son propre groupe de cinq et que les broches opposées ne se touchent pas. Les cartes comme l'Arduino Nano et le Raspberry Pi Pico se placent de la même façon au-dessus du canal. Comme le canal garde les deux moitiés indépendantes, c'est aussi une manière propre de brancher des boutons et des composants à deux pattes.
Les longues lignes en haut et en bas de la plaque sont les rails d'alimentation. Le rail à ligne rouge sert en général au + (5 V ou 3,3 V), celui à ligne bleue ou noire au − (GND). Contrairement aux colonnes, ces rails sont reliés à l'horizontale, sur toute la longueur de la plaque. Si tu amènes les broches 5V et GND de l'Arduino aux rails avec un câble chacune, tu peux alimenter n'importe quel composant de la plaque avec un petit câble. Les rails du haut et du bas ne sont pas reliés entre eux ; si tu veux de l'alimentation des deux côtés, relie-les à une extrémité avec un câble.
| Zone | Comment est-elle reliée ? | À quoi sert-elle ? |
|---|---|---|
| Trous a–e (chaque colonne) | Les 5 trous d'une même colonne sont reliés | Réunir les pattes des composants |
| Trous f–j (chaque colonne) | Les 5 trous d'une même colonne sont reliés, sans lien avec a–e | L'autre moitié du canal |
| Canal central | Aucune liaison, sépare les deux moitiés | Circuits intégrés, Nano, Pico, boutons |
| Rail d'alimentation (+) | Relié à l'horizontale sur toute la plaque | Distribution du 5 V ou du 3,3 V |
| Rail d'alimentation (−) | Relié à l'horizontale sur toute la plaque | Distribution de la masse (GND) |
Premier circuit LED : pas à pas et sans code
Pour la première expérience, on n'utilise le microcontrôleur que comme source d'alimentation ; ainsi, si quelque chose ne va pas, tu sais que le problème vient du câblage et non du code. Il te faut : une carte Arduino Uno, une LED rouge, une résistance de 220 Ω (bandes rouge-rouge-marron) et trois câbles jumper.
- Travaille sans le câble USB branché. Relie d'abord la broche GND de l'Arduino au rail bleu (−) et la broche 5V au rail rouge (+).
- Enfonce une patte de la résistance de 220 Ω dans le rail + et l'autre patte dans le trou 10a, par exemple.
- Place la patte longue (anode) de la LED dans le trou 10e : elle se retrouve dans la même colonne que la résistance, donc au même point.
- Place la patte courte (cathode) de la LED dans le trou 11e. Les deux pattes doivent être dans des colonnes différentes, sinon la LED est court-circuitée.
- Tire un petit câble du trou 11a vers le rail bleu (−). Le circuit est maintenant complet : rail +, résistance, LED, rail −.
- Branche le câble USB. Si la LED s'allume, le circuit est bon ; sinon, retourne la LED et réessaie.
Dans ce circuit, tu peux calculer le courant dans la LED avec la loi d'Ohm : une LED rouge chute environ 2 V, il reste 3 V aux bornes de la résistance et le courant vaut I = 3 V / 220 Ω ≈ 13,6 mA. Cette valeur est sans danger pour la LED et donne une luminosité suffisante. Si tu utilises une autre couleur ou une autre tension, trouve la bonne valeur avec le calculateur de résistance pour LED ; si tu n'es pas sûr de la valeur de ta résistance, déchiffre les bandes avec l'outil de code couleur des résistances. Pour plus de détails, lis l'article calcul de la résistance d'une LED.
Faire clignoter la LED avec Arduino
Maintenant que le circuit fonctionne, retire la patte de la résistance qui allait au rail + et relie-la, dans la même colonne, à un câble allant vers une broche numérique de l'Arduino. Le tableau ci-dessous regroupe les branchements utilisés dans toutes les expériences de cet article pour les trois cartes ; la ligne du bouton concerne la deuxième expérience, dans la partie ESP32 et Pico. Si tu as du mal à trouver les broches sur ta carte, utilise l'outil de brochage.
| Branchement | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Signal de la LED (via 220 Ω) | D8 | GPIO 18 | GP14 (broche physique 19) |
| Bouton (autre patte à GND) | D2 | GPIO 4 | GP15 (broche physique 20) |
| Rail d'alimentation + | 5V | 3V3 | 3V3(OUT) (broche physique 36) |
| Rail d'alimentation − | GND | GND | GND (broche physique 18 ou 38) |
1const int LED_PIN = 8; // LED'in bağlı olduğu pin / pin the LED is connected to
2
3void setup() {
4 pinMode(LED_PIN, OUTPUT); // pini çıkış yap / set the pin as output
5}
6
7void loop() {
8 digitalWrite(LED_PIN, HIGH); // LED'i yak / turn the LED on
9 delay(500); // 0,5 saniye bekle / wait 0.5 s
10 digitalWrite(LED_PIN, LOW); // LED'i söndür / turn the LED off
11 delay(500);
12}Le code est très court mais idéal pour tester la breadboard : pinMode configure D8 en sortie, digitalWrite met la broche à 5 V (HIGH) ou à 0 V (LOW), et delay attend une demi-seconde. Si la LED clignote une fois par seconde, c'est que le câblage et le téléversement sont corrects. L'Arduino Uno ne s'enfiche pas sur la breadboard ; on la relie avec des câbles jumper depuis ses broches. L'Arduino Nano, lui, se place sur le canal central comme un circuit intégré et laisse trois trous libres à côté de chaque broche.
Placer l'ESP32 sur la breadboard

Les cartes ESP32 DevKit (versions à 30 et 38 broches) sont nettement plus larges que l'Arduino Nano. Quand tu les enfiches sur le canal central d'une breadboard standard, les deux rangées de broches occupent presque toute la largeur : il reste au plus un ou deux trous libres à côté de chaque broche et, sur certains modèles, un côté est entièrement bloqué. Tu n'as alors plus de place pour brancher des câbles. Avant de poser la carte, décide quelles broches tu vas utiliser et vérifie que les pattes sont droites. Pour la retirer, ne la soulève pas par un seul bout : tire des deux côtés avec la même force en la balançant légèrement, pour ne pas plier les broches. Pour mieux connaître la carte, lis l'article qu'est-ce que l'ESP32.
- Deux breadboards côte à côte : sur la plupart des breadboards, le rail latéral est emboîté et se retire en le faisant glisser. Retire le rail intermédiaire pour assembler deux plaques et pose l'ESP32 à cheval au milieu ; il reste beaucoup de trous de chaque côté.
- Garde les broches utiles dégagées : si ton projet n'utilise qu'une rangée de broches, décale la carte pour qu'il reste deux trous libres à côté de cette rangée.
- Jumpers mâle-femelle : tu peux laisser l'ESP32 hors de la breadboard et ne ramener que les broches nécessaires avec des câbles à extrémité femelle.
- Règle du 3,3 V : relie la broche 3V3 de l'ESP32 au rail +. Si tu utilises aussi du 5 V sur la même carte, mets les deux tensions sur des rails séparés et ne branche jamais du 5 V sur une broche GPIO.
Montons maintenant la deuxième expérience : cette fois, on allume la LED avec un bouton. Place le bouton à quatre pattes à cheval sur le canal central. Une patte va dans la colonne du GPIO 4 et la patte diagonalement opposée va au rail −. La LED se branche sur le GPIO 18 via une résistance de 220 Ω. À 3,3 V, la LED rouge est traversée par environ (3,3 − 2) / 220 ≈ 6 mA ; c'est suffisant pour une luminosité bien visible. On n'utilise pas de résistance externe pour le bouton, car on active la résistance de pull-up interne de l'ESP32.
1const int LED_PIN = 18; // LED + 220 ohm / LED + 220 ohm
2const int BUTTON_PIN = 4; // buton, diğer bacağı GND / button, other leg to GND
3
4void setup() {
5 pinMode(LED_PIN, OUTPUT);
6 pinMode(BUTTON_PIN, INPUT_PULLUP); // dahili pull-up açık / internal pull-up on
7}
8
9void loop() {
10 bool pressed = (digitalRead(BUTTON_PIN) == LOW); // basılıyken LOW okunur / reads LOW while pressed
11 digitalWrite(LED_PIN, pressed ? HIGH : LOW);
12 delay(10); // kısa bekleme / short pause
13}Placer le Raspberry Pi Pico sur la breadboard
Le Raspberry Pi Pico semble dessiné aux mesures de la breadboard. L'écartement entre ses deux rangées de broches est de 17,78 mm (0,7 pouce) : si tu l'enfiches sur le canal avec les broches dans les rangées c et h, il reste deux trous libres (a–b et i–j) à côté de chaque broche. Le Pico est souvent livré sans barrettes soudées ; si tu n'as pas pris la version H avec connecteurs, tu devras souder toi-même deux barrettes mâles 2 × 20. Les numéros de broches sont imprimés sur la face inférieure de la carte et non sur le dessus, donc difficiles à lire une fois en place ; retiens que la broche physique 1 se trouve côté USB, en haut à gauche. Pour mieux connaître la carte, lis l'article qu'est-ce que le Raspberry Pi Pico.
Réalisons la même expérience bouton et LED sur le Pico en MicroPython. La LED va de GP14 (broche physique 19) au rail − via une résistance de 220 Ω ; comme la broche physique 18, juste à côté, est déjà une masse, relier le rail − est très simple. Le bouton se branche sur GP15 (broche physique 20) et sa patte en diagonale va, là aussi, au rail −.
1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT) # GP14 (fiziksel pin 19) / GP14 (physical pin 19)
5buton = Pin(15, Pin.IN, Pin.PULL_UP) # GP15 (fiziksel pin 20), dahili pull-up / internal pull-up
6
7while True:
8 if buton.value() == 0: # basılıyken 0 okunur / reads 0 while pressed
9 led.value(1)
10 else:
11 led.value(0)
12 time.sleep_ms(10) # kısa bekleme / short pauseOrganisation des câbles jumper : monter un circuit lisible

Quand le circuit grossit, la vraie difficulté ne vient plus des composants mais des câbles. Des câbles longs, de couleurs aléatoires, qui se croisent rendent la recherche d'erreurs impossible et, quand tu en tires un, un autre contact peut se débrancher. Les habitudes suivantes semblent anodines, mais elles raccourcissent nettement ton débogage.
- Fixe une règle de couleurs et respecte-la : rouge toujours pour le +, noir ou bleu toujours pour le GND. Utilise les autres couleurs (jaune, vert, orange) pour les signaux.
- Câbles courts et plats : pour les liaisons sur la plaque, préfère des kits de câbles de pont coupés et pliés, qui restent à plat, plutôt que de longs câbles souples.
- Raccourcis les pattes : si tu raccourcis les pattes des résistances et des LED que tu gardes en place, les composants ne bougent pas en l'air et ne touchent pas leurs voisins.
- Le bon type de câble : les câbles mâle-mâle servent entre la breadboard et l'Arduino, les mâle-femelle sur les broches des modules, et les femelle-femelle pour relier directement les broches de deux modules.
- Découpe en zones : regroupe les entrées (bouton, capteur) d'un côté de la plaque et les sorties (LED, buzzer) de l'autre, et mets le microcontrôleur à une extrémité.
- Ne branche pas un fil multibrin directement : les fils fins dont les brins s'effilochent cassent dans les trous et abîment les clips ; utilise toujours des câbles à embouts ou des fils monobrin.
- Prends une photo : avant de démonter un circuit qui fonctionne, prends-le en photo vu de dessus ; c'est le guide le plus rapide si tu veux le remonter.
Premières idées de projets avec la breadboard
- Feu tricolore : consolide la logique des colonnes avec trois LED et trois résistances ; les étapes sont dans l'article feu tricolore Arduino.
- LED chenillard : aligne six LED sur des colonnes voisines et réalise les effets Knight Rider et chenillard.
- Marche/arrêt avec un bouton : approfondis le branchement d'un bouton sur le canal et le principe de l'anti-rebond avec l'article comment brancher un bouton.
- Réglage de la luminosité : fais varier la luminosité de la LED avec un potentiomètre ; tu apprendras à placer un composant à trois pattes dans trois colonnes différentes.
- Veilleuse : monte un diviseur de tension avec une photorésistance LDR et une résistance pour allumer automatiquement la LED dans le noir.
- Alimentation externe : si tu utilises un moteur ou beaucoup de LED, alimente les rails en 5 V et 3,3 V avec le module d'alimentation MB102 pour breadboard.
Erreurs courantes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| La LED ne s'allume pas du tout | LED montée à l'envers, ou résistance et patte de LED pas dans la même colonne | Patte longue côté +, et mets les pattes qui se rejoignent (résistance et LED) dans le même groupe de 5 |
| Une moitié de la plaque ne fonctionne pas | Rail d'alimentation coupé au milieu | Relie les deux moitiés du rail avec un petit câble de pont |
| La résistance chauffe, la LED est trop lumineuse ou grille | Les deux pattes de la résistance sont dans la même colonne : elle est court-circuitée | Mets les pattes de la résistance dans des colonnes différentes |
| Le bouton semble toujours appuyé | Deux pattes du bouton reliées en interne ont été utilisées | Place le bouton sur le canal et utilise les pattes en diagonale |
| Un capteur ou un module donne des valeurs absurdes | Pas de GND commun avec l'alimentation externe | Relie le GND de l'alimentation à celui de la carte |
| Le circuit ne marche que quand on le touche | Clip lâche, patte trop fine ou trou usé | Déplace le composant dans une autre zone, utilise un fil monobrin de 22 AWG |
| L'ESP32 ou le Pico chauffe, une broche est détruite | Rail 5 V appliqué à une broche 3,3 V | Étiquette les rails, n'utilise que 3V3 sur les cartes en 3,3 V |
| Câbles et clips qui chauffent | Une charge à fort courant, comme un moteur, est alimentée via la breadboard | Alimente les forts courants avec des câbles séparés, via un module pilote |
Dès que tu utilises une alimentation externe, un adaptateur ou une pile, le sujet le plus souvent oublié est la masse commune. Pour que le microcontrôleur comprenne un signal « haut » ou « bas », les deux circuits doivent partager la même référence GND ; tu trouveras des exemples sur l'importance de ce point dans l'article GND et masse commune. N'oublie pas non plus que les clips des zones souvent débranchées se desserrent avec le temps. Si tu as toujours des problèmes dans les mêmes trous, déplacer le composant de quelques colonnes résout souvent le problème tout de suite.
Une fois la logique de la breadboard bien en tête, chaque nouveau capteur ou module n'est plus qu'à quelques câbles. Quand ton circuit a passé les essais et fonctionne comme tu veux, tu peux le rendre permanent sur une plaque perforée. Dans l'application BlueGrays, tu peux suivre pas à pas l'allumage d'une LED, le feu tricolore, la LED commandée par bouton et les premiers projets ESP32 et Pico, avec des schémas montrant le placement sur la breadboard et du code prêt à l'emploi.
Questions fréquentes
Quels trous d'une breadboard sont reliés entre eux ?
Dans chaque colonne numérotée, les cinq trous a–e sont reliés entre eux, et les cinq trous f–j aussi. Le canal central sépare ces deux groupes. Les rails + et − sur les bords sont, eux, reliés à l'horizontale sur toute la longueur de la plaque.
Pourquoi le rail d'alimentation de ma breadboard ne fonctionne-t-il pas ?
Sur la plupart des breadboards au format complet, les rails d'alimentation sont coupés en deux au milieu et les deux moitiés ne sont pas reliées. S'il y a une interruption au milieu de la ligne rouge ou bleue, le rail est coupé. Relie les deux moitiés avec un petit câble de pont et le problème est réglé ; pour t'en assurer, utilise le mode continuité du multimètre.
Quel courant une breadboard peut-elle supporter ?
Les clips d'une breadboard sont généralement jugés sûrs jusqu'à environ 1 A, avec une tension faible (le plus souvent sous 5 V ou 12 V). C'est largement suffisant pour des circuits avec LED, capteurs et microcontrôleurs. Les moteurs, les longs rubans de LED et la tension secteur de 220 V ne doivent pas passer par une breadboard.
Pourquoi l'ESP32 ne rentre-t-il pas sur ma breadboard ?
Les cartes ESP32 DevKit sont larges : sur une breadboard standard, il reste au plus un ou deux trous à côté des broches, et parfois un côté est entièrement bloqué. Pour y remédier, tu peux assembler deux breadboards côte à côte en retirant le rail intermédiaire et poser l'ESP32 au milieu. Autre solution : garder la carte à l'extérieur et la relier avec des jumpers mâle-femelle.
Dans quel sens dois-je brancher la LED sur la breadboard ?
La patte longue de la LED est l'anode (+), la patte courte est la cathode (−), et le bord du boîtier est plat côté cathode. La patte longue se met dans la même colonne que la résistance, la patte courte dans la colonne qui va vers le rail GND. Veille à ce que les deux pattes ne soient pas dans le même groupe de 5, sinon la LED est court-circuitée et ne s'allume pas.
Dois-je acheter une breadboard de 400 ou de 830 trous ?
Pour des projets de débutant avec un capteur et quelques LED, l'Arduino Nano et le Raspberry Pi Pico, une demi-breadboard de 400 trous suffit. Si tu utilises un ESP32 ou si tu veux brancher plusieurs modules en même temps, une breadboard complète de 830 trous est plus confortable. Assembler deux demi-plaques est aussi une option flexible.
Projets à réaliser après cet article
Voir tous les projets
Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Deux LED clignotant en alternance
Deux LED clignotent vite à tour de rôle : quand l'une s'allume, l'autre s'éteint, comme si elles se renvoyaient une balle.

Feu de circulation
Une copie miniature du feu tricolore que tu vois chaque jour dans la rue. Le rouge reste allumé deux secondes, l'orange brille un court instant, le vert reste deux secondes, puis on revient au rouge…

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.

Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

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.

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

Raspberry Pi Pico Deux LEDs alternées (Flip-Flop)
L'étape suivante après la LED unique sur le Pico : deux LEDs clignotent alternativement dans un motif flip-flop classique. Deux LEDs de couleurs différentes (rouge sur GP14, verte sur GP13) échangent leur état toutes les 500ms. Pin.toggle() de MicroPython rend le code court. Base des feux de circulation, gyrophares.
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

