Comprends l'électricité, construis des circuits, et passe du breadboard au PCB.
Tout ce qu'il faut pour devenir un vrai maker.
Imagine un système de tuyaux avec un réservoir en hauteur. L'électricité fonctionne exactement comme ça :
L'ANALOGIE EAU → ÉLECTRICITÉ
Réservoir haut = Batterie (source de tension)
Hauteur du réservoir = Tension (Volts) — la "pression"
Débit d'eau = Courant (Ampères) — le "flux"
Étroitesse du tuyau = Résistance (Ohms) — le "frein"
┌─────────────┐
│ Réservoir │ ← Plus c'est haut = plus de tension (V)
│ ~~~water │
└──────┬───────┘
│ ← Tuyau (fil électrique)
╔════╧════╗
║ ÉTROIT ║ ← Résistance (Ω) : freine le débit
╚════╤════╝
▼ ← Débit = Courant (A)
┌─────────┐
│ Turbine │ ← Composant (LED, moteur...)
└─────────┘
Tension (V — Volts) — La "pression" électrique. Pile AA = 1.5V, USB = 5V, prise murale = 230V.
Courant (I — Ampères) — La quantité d'électrons qui passent. LED ~20mA, moteur DC ~200mA.
Résistance (R — Ohms Ω) — Combien le composant freine le courant. Fil de cuivre ≈ 0Ω, résistance 1kΩ = frein modéré.
Sécurité ! Le courant tue, pas la tension seule. À partir de 30mA à travers le corps = mortel. Pile 9V = safe, prise 230V = danger. Ne touche JAMAIS au courant secteur.
╔══════════════════════════════════════════════╗
║ V = I × R ║
║ ║
║ V (Volts) = I (Ampères) × R (Ohms) ║
║ I = V / R → trouver le courant ║
║ R = V / I → trouver la résistance ║
╚══════════════════════════════════════════════╝
Le triangle : ┌───┐
│ V │ Couvre ce que tu cherches :
├───┤ V → I × R
│I×R│ I → V / R
└───┘ R → V / I
LED rouge sur Arduino 5V. LED = 2V, max 20mA. Quelle résistance ?
V résistance = 5V - 2V = 3V
R = V / I = 3 / 0.02 = 150Ω → prends 220Ω (safe)
Arduino 5V ──[220Ω]──►|── GND
LED
I = V / R = 9 / 1000 = 0.009A = 9mA → parfait pour une LED
Astuce : Utilise kΩ et mA directement : V = mA × kΩ → résultat en Volts. 20mA × 0.22kΩ = 4.4V.
CODE COULEUR DES RÉSISTANCES (4 bandes)
Couleur Chiffre Multiplicateur Tolérance
───────── ─────── ────────────── ─────────
Noir 0 ×1
Marron 1 ×10 ±1%
Rouge 2 ×100 ±2%
Orange 3 ×1k
Jaune 4 ×10k
Vert 5 ×100k ±0.5%
Bleu 6 ×1M
Violet 7
Gris 8
Blanc 9
Or ×0.1 ±5%
Argent ×0.01 ±10%
Exemple : Rouge-Violet-Marron-Or = 270Ω ±5%
Mnémo : Ne Mangez Rien Ou Jeûnez,
Voilà Bien Votre Grande Bêtise
Émet de la lumière dans un seul sens (anode+ → cathode-). Toujours avec résistance sinon elle grille !
Rouge=2V, Vert=2.1V, Bleu/Blanc=3.2V
Stocke de l'énergie temporairement, comme une mini-batterie ultra-rapide. Filtre le bruit, lisse l'alimentation, crée des timings.
Unité : Farads (µF, nF, pF)
Laisse passer le courant dans un seul sens (clapet anti-retour). La LED est une diode qui brille ! Protège les circuits.
Tension forward : ~0.7V (silicium)
Interrupteur commandé électriquement. Petit courant sur la "base" → gros courant entre collecteur et émetteur. Le cerveau de l'électronique.
Types : NPN, PNP, MOSFET
Polarités ! LEDs, condensateurs électrolytiques et diodes ont un sens. À l'envers : ça marche pas, et certains condensateurs explosent. Vérifie toujours + et -.
CIRCUIT SÉRIE — Un seul chemin
══════════════════════════════
┌──[R1=100Ω]──[R2=200Ω]──[R3=300Ω]──┐
│ │
[+9V] [GND]
R total = R1 + R2 + R3 = 600Ω
I = 9 / 600 = 15mA (même courant partout)
V sur R1 = 1.5V, R2 = 3.0V, R3 = 4.5V → Total = 9V ✓
CIRCUIT PARALLÈLE — Plusieurs chemins
══════════════════════════════════════
┌────[R1=300Ω]────┐
├────[R2=300Ω]────┤
├────[R3=300Ω]────┤
│ │
[+9V] [GND]
1/Rt = 1/300 + 1/300 + 1/300 = 1/100 → Rt = 100Ω
Même tension (9V) sur chaque résistance
I total = 90mA (30mA par branche)
Série : R s'additionnent, courant identique, tension se divise.
Parallèle : R diminue, tension identique, courant se divise.
Ampoule grillée en série → tout s'éteint. En parallèle → les autres continuent.
Le breadboard permet de tester des circuits sans souder. Les composants s'enfichent dans les trous.
ANATOMIE D'UN BREADBOARD
════════════════════════
Rail + (rouge) ● ● ● ● ● ● ● ● ● ● tout connecté →
Rail - (bleu) ● ● ● ● ● ● ● ● ● ● tout connecté →
──────────────────────────
a b c d e │ f g h i j
Rangée 1 ● ● ● ● ● │ ● ● ● ● ●
Rangée 2 ● ● ● ● ● │ ● ● ● ● ●
Rangée 3 ● ● ● ● ● │ ● ● ● ● ●
... ... │ ...
Rangée 30 ● ● ● ● ● │ ● ● ● ● ●
──────────────────────────
Rail + ● ● ● ● ● ● ● ● ● ●
Rail - ● ● ● ● ● ● ● ● ● ●
► a-b-c-d-e connectés (même rangée)
► f-g-h-i-j connectés (même rangée)
► Fossé central sépare les 2 côtés
► Rails ± connectés sur toute la longueur
Erreurs classiques :
• Rails coupés au milieu sur grands breadboards — relie-les !
• Court-circuit — Deux pattes sur la même rangée.
• Mauvais contact — Réenfiche les fils si ça marche pas.
• IC mal placé — Encoche en haut, pattes des deux côtés du fossé.
Un transistor est un interrupteur commandé électriquement. Un petit courant sur la Base contrôle un gros courant entre Collecteur et Émetteur. Ton CPU en contient des milliards.
TRANSISTOR NPN (ex: 2N2222, BC547)
═══════════════════════════════════
Collecteur (C)
│
┌────┴────┐
Base ──┤ NPN │ Petit courant B→E
(B) │ │ "ouvre" le gros courant C→E
└────┬────┘
Émetteur (E)
COMME INTERRUPTEUR :
Arduino pin 9 ──[1kΩ]──► Base
│
+12V ──[Moteur]──────► Collecteur
│
Émetteur ──► GND
→ Arduino envoie 5mA sur la Base
→ Transistor laisse passer 500mA du moteur
→ Arduino contrôle 12V sans griller !
NPN → ON quand Base = HIGH (le + courant)
PNP → ON quand Base = LOW (logique inversée)
Le gain (β) = courant collecteur / courant base. BC547 ≈ gain 200. Donc 1mA sur la base → 200mA au collecteur. C'est un amplificateur de courant !
En saturation (interrupteur ON), on surdimensionne le courant de base pour garantir que le transistor est complètement ouvert.
Toujours une résistance sur la Base ! Sans ça → transistor grillé. Valeur typique : 1kΩ à 10kΩ.
Le pont en H utilise 4 interrupteurs en H autour du moteur pour inverser le sens du courant.
LE PONT EN H — Principe
════════════════════════
+V ──┬───────────┬── +V
│ │
[S1] [S3]
│ │
├──[MOT]────┤
│ ← → │
[S2] [S4]
│ │
GND ─┴───────────┴── GND
Sens 1 → : S1+S4 fermés Sens 2 ← : S2+S3 fermés
Frein : S1+S3 fermés Stop : tous ouverts
⚠️ JAMAIS S1+S2 ou S3+S4 = COURT-CIRCUIT !
Module tout-en-un pour 2 moteurs DC. Pas besoin de construire le H-Bridge à la main !
L298N — Branchements Arduino L298N Moteurs Pin 9 ─► ENA (vitesse A) Moteur A : OUT1, OUT2 Pin 8 ─► IN1 (sens) Pin 7 ─► IN2 (sens) Pin 6 ─► ENB (vitesse B) Moteur B : OUT3, OUT4 Pin 5 ─► IN3 (sens) Pin 4 ─► IN4 (sens) +12V batterie ──► +12V input GND commun ─────► GND (Arduino + L298N + batterie) ┌──────┬──────┬──────────┐ │ IN1 │ IN2 │ Moteur │ ├──────┼──────┼──────────┤ │ HIGH │ LOW │ Sens → │ │ LOW │ HIGH │ Sens ← │ │ LOW │ LOW │ Stop │ │ HIGH │ HIGH │ Frein │ └──────┴──────┴──────────┘ ENA = analogWrite() pour vitesse (PWM 0-255)
// Contrôle moteur avec L298N #define ENA 9 #define IN1 8 #define IN2 7 void setup() { pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); } void loop() { // Avant — pleine vitesse digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); analogWrite(ENA, 255); delay(2000); // Arrière — demi-vitesse digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); analogWrite(ENA, 128); delay(2000); // Stop analogWrite(ENA, 0); delay(1000); }
Un condensateur stocke de l'énergie et la relâche très vite. Capacité en Farads (F). En pratique : µF (micro), nF (nano), pF (pico).
3 UTILISATIONS DES CONDENSATEURS
═════════════════════════════════
1. FILTRAGE (découplage)
100nF près de chaque puce → filtre le bruit
+5V ──┬── [puce]
[100nF]
GND ──┘
2. LISSAGE D'ALIMENTATION
Gros condo (100-1000µF) après régulateur
Batterie ─[régulateur]─┬── +5V stable
[470µF]
GND
3. CIRCUIT RC (timing)
+5V ──[R=10kΩ]──┬── Sortie
[C=100µF]
GND
Temps charge ≈ R×C = 10000 × 0.0001 = 1s
63% en 1×RC, 95% en 3×RC, 99% en 5×RC
Condensateurs électrolytiques = polarisés ! Patte longue = +, bande marquée = -. À l'envers : ils gonflent et explosent. Les céramiques (petits, plats) n'ont pas de polarité.
Tourne le bouton → la couleur change à travers tout le spectre. On utilise le PWM (analogWrite) pour mélanger rouge, vert et bleu.
Matériel : Arduino Uno, LED RGB cathode commune, 3× résistance 220Ω, potentiomètre 10kΩ, breadboard, fils.
CÂBLAGE LAMPE RGB
══════════════════
Potentiomètre 10kΩ :
Gauche → GND | Milieu → A0 | Droite → +5V
LED RGB (cathode commune) :
Cathode (patte longue) → GND
Pin 9 ──[220Ω]── Rouge
Pin 10 ──[220Ω]── Vert
Pin 11 ──[220Ω]── Bleu
Arduino Breadboard
─────── ──────────
A0 ─────────── Potentiomètre (milieu)
9 ──[220Ω]── LED Rouge
10 ──[220Ω]── LED Vert
11 ──[220Ω]── LED Bleu
GND ────────── Cathode LED + Pot gauche
5V ────────── Pot droite
// Lampe RGB — Cycle de couleurs au potentiomètre const int POT = A0; const int RED = 9; const int GRN = 10; const int BLU = 11; void setup() { pinMode(RED, OUTPUT); pinMode(GRN, OUTPUT); pinMode(BLU, OUTPUT); } void loop() { int val = analogRead(POT); // 0-1023 int hue = map(val, 0, 1023, 0, 767); int r, g, b; if (hue < 256) { // Rouge → Vert r = 255 - hue; g = hue; b = 0; } else if (hue < 512) { // Vert → Bleu r = 0; g = 511 - hue; b = hue - 256; } else { // Bleu → Rouge r = hue - 512; g = 0; b = 767 - hue; } analogWrite(RED, r); analogWrite(GRN, g); analogWrite(BLU, b); delay(10); }
PWM (Pulse Width Modulation) : analogWrite(pin, 0-255) ne produit pas une vraie tension variable — il allume/éteint le pin ultra-rapidement. 128 = allumé 50% du temps. Tes yeux perçoivent ça comme une luminosité réduite. Malin !
On utilise une LDR (Light Dependent Resistor) — sa résistance change avec la lumière. Dans le noir : résistance haute. En pleine lumière : résistance basse.
Matériel : Arduino, LDR, résistance 10kΩ, LED, résistance 220Ω.
LE DIVISEUR DE TENSION
═══════════════════════
+5V ──[LDR]──┬──[10kΩ]── GND
│
└── A0 (Arduino lit la tension ici)
• Lumière → LDR ≈ 1kΩ → V(A0) ≈ 5 × 10/(1+10) ≈ 4.5V
• Noir → LDR ≈ 100kΩ → V(A0) ≈ 5 × 10/(100+10) ≈ 0.45V
L'Arduino lit une valeur haute = lumière, basse = noir.
LED de sortie :
Arduino pin 9 ──[220Ω]──►|── GND
LED
// Détecteur d'obscurité — allume LED quand il fait sombre const int LDR_PIN = A0; const int LED_PIN = 9; const int SEUIL = 300; // Ajuste selon ton environnement void setup() { pinMode(LED_PIN, OUTPUT); Serial.begin(9600); } void loop() { int lumiere = analogRead(LDR_PIN); Serial.print("Lumière : "); Serial.println(lumiere); if (lumiere < SEUIL) { // Il fait sombre → allume la LED digitalWrite(LED_PIN, HIGH); } else { // Il fait clair → éteint la LED digitalWrite(LED_PIN, LOW); } delay(100); }
Pour aller plus loin : Remplace digitalWrite par analogWrite pour que la LED s'allume progressivement quand il fait plus sombre. Mappe la valeur du capteur sur 0-255 avec map().
Ton circuit marche sur breadboard ? Maintenant on le rend permanent. Un PCB (Printed Circuit Board) remplace les fils par des pistes en cuivre gravées sur une plaque.
WORKFLOW : BREADBOARD → PCB
════════════════════════════
1. PROTOTYPE sur breadboard
→ Teste, debug, itère
2. SCHÉMATIQUE dans KiCad
→ Dessine le circuit avec des symboles
→ Vérifie les connexions (ERC)
3. ROUTAGE du PCB
→ Place les composants sur la carte
→ Trace les pistes en cuivre
→ Vérifie le design (DRC)
4. FABRICATION
→ Exporte les fichiers Gerber
→ Envoie à un fabricant (JLCPCB, PCBWay)
→ 5 cartes pour ~2€ + livraison !
5. ASSEMBLAGE
→ Soude les composants sur le PCB
→ Teste et admire ton travail !
KiCad est un logiciel open-source utilisé par les pros et les makers. Il fait tout : schématique, routage PCB, visualisation 3D, génération de fichiers de fabrication.
Télécharge-le sur kicad.org — c'est gratuit et disponible sur Windows, Mac et Linux.
LES ÉTAPES DANS KICAD ═══════════════════════ Éditeur de schématique : ┌──────────────────────────────────────┐ │ │ │ [R1]──────┬──────[LED1] │ │ │ │ │ │ [C1] [R2=220Ω] │ │ │ │ │ │ [+5V]─────┘ [GND] │ │ │ └──────────────────────────────────────┘ → Éditeur de PCB : ┌──────────────────────────────────────┐ │ ┌───┐ ┌───┐ │ │ │R1 ├═════════┤C1 │ │ │ └───┘ ║ └───┘ │ │ ║ │ │ ┌────╨────┐ │ │ │ LED1 │ Pistes cuivre │ │ └────┬────┘ en vert │ │ ║ │ │ ┌───┐ ║ │ │ │R2 ├═══╝ │ │ └───┘ │ └──────────────────────────────────────┘ → Visualisation 3D avant fabrication !
Largeur des pistes : 0.25mm minimum (signaux), 0.5mm+ pour l'alimentation. Plus le courant est fort, plus la piste doit être large.
Plan de masse : Remplis le cuivre non-utilisé avec du GND. Ça réduit le bruit et améliore les performances.
Condensateurs de découplage : Place un 100nF le plus près possible de chaque puce. C'est LA règle numéro 1.
Espacement : 0.2mm min entre les pistes. Plus pour la haute tension.
Astuce budget : Des fabricants comme JLCPCB font 5 PCBs de 100×100mm pour environ 2€ (+ ~5€ de livraison). Tu peux même leur faire souder les composants (assemblage SMT). Le futur, c'est maintenant !
Loi d'Ohm, LEDs avec résistances, breadboard, circuits série/parallèle. Tu sais calculer et brancher.
Transistors, H-Bridge, condensateurs, diviseurs de tension, PWM. Tu construis des vrais projets.
Design PCB avec KiCad, soudure SMD, communication SPI/I2C, régulateurs de tension, filtres actifs.
Ressources recommandées :
• Tinkercad Circuits — Simule des circuits Arduino en ligne gratuitement
• Falstad Circuit Simulator — Visualise le courant en temps réel
• KiCad — Design PCB professionnel, gratuit et open-source
• Ben Eater (YouTube) — Construit un CPU from scratch (anglais, sous-titres dispo)