Ruban LED RGB Arduino : piloter du 12 V avec des MOSFET
Ruban LED RGB avec Arduino : pilote un ruban 5050 12 V avec des MOSFET IRLZ44N, PWM sur 3 canaux, fondu de couleurs, potentiomètre, code ESP32 et Pico.
Le contrôle d'un ruban LED RGB avec Arduino, c'est piloter les canaux rouge, vert et bleu d'un ruban 5050 12 V non adressable avec trois signaux PWM séparés pour obtenir la couleur voulue. Les broches d'Arduino ne supportent ni les ampères que le ruban consomme ni les 12 V, donc on place un MOSFET par canal : Arduino envoie seulement un signal 5 V sur la grille du MOSFET, et c'est lui qui encaisse le courant. Tu peux ainsi commander des mètres de ruban en toute sécurité avec un petit microcontrôleur.
Dans ce guide, tu découvres la structure d'un ruban 5050, le bon choix de MOSFET, le câblage et le calcul de l'alimentation. Ensuite, tu mélanges les couleurs avec un Arduino Uno, tu fais un fondu fluide basé sur millis() et tu choisis teinte et luminosité avec des potentiomètres, puis tu fais tourner le même montage avec l'unité LEDC de l'ESP32 et le PWM MicroPython du Raspberry Pi Pico. Tu verras aussi la différence avec le WS2812B et, à la fin, les erreurs les plus fréquentes avec leurs solutions.
Qu'est-ce qu'un ruban LED RGB et comment fonctionne-t-il ?
Dans un ruban RGB non adressable, chaque boîtier SMD 5050 contient trois puces LED : rouge, vert et bleue. Le ruban est formé de segments 12 V montés en parallèle, chacun avec trois LED et une résistance de limitation par couleur ; la tension directe cumulée des LED en série est d'environ 6 à 9 V selon la couleur, et la résistance absorbe le reste. Le ruban a quatre fils : le plus commun (+12V), puis R, G et B. C'est donc un ruban à anode commune : pour allumer une couleur, il faut tirer sa ligne vers la masse. Tout le ruban affiche la même couleur en même temps ; tu ne peux pas régler chaque LED séparément. La couleur dépend du rapport cyclique PWM de chaque canal : rouge et vert à fond donnent du jaune, les trois à fond donnent une lumière proche du blanc.
| Caractéristique | Ruban 30 LED/m | Ruban 60 LED/m |
|---|---|---|
| Type de LED | 5050 SMD (5,0 × 5,0 mm, 3 puces) | 5050 SMD (5,0 × 5,0 mm, 3 puces) |
| Tension de fonctionnement | 12 V DC | 12 V DC |
| Puissance (blanc max) | Environ 7,2 W/m | Environ 14,4 W/m |
| Courant (blanc max) | Environ 0,6 A/m | Environ 1,2 A/m |
| Courant par canal | Environ 0,2 A/m | Environ 0,4 A/m |
| Pas de découpe | Toutes les 3 LED (10 cm) | Toutes les 3 LED (5 cm) |
| Fils | +12V, R, G, B | +12V, R, G, B |
Différence entre ruban RGB et WS2812B
Les deux rubans donnent de la lumière RGB, mais leur logique de commande est totalement différente. Le ruban non adressable ressemble à une lampe : tu règles la couleur de tout le ruban en changeant la luminosité des trois canaux. Dans un ruban WS2812B NeoPixel, chaque LED contient une petite puce de pilotage et tu envoies une couleur différente à chaque LED par une seule ligne de données. Le tableau suivant t'aide à choisir :
| Caractéristique | Ruban RGB 12 V (5050) | Ruban WS2812B |
|---|---|---|
| Commande | Tout le ruban d'une seule couleur | Une couleur par LED |
| Alimentation | 12 V (versions 24 V aussi) | 5 V |
| Câblage | 4 fils : +12V, R, G, B | 3 fils : 5V, DIN, GND |
| Circuit de puissance | Un MOSFET par canal | Inutile, une seule broche de données suffit |
| Code | analogWrite / PWM | Bibliothèque FastLED ou Adafruit NeoPixel |
| Courant (60 LED/m, blanc max) | Environ 1,2 A/m (12 V) | Environ 3,6 A/m (5 V) |
| Chute de tension | Rarement un problème jusqu'à 5 m | Alimentation en plusieurs points sur les longs rubans |
| Effets | Couleur fixe, fondu, respiration | Défilement, arc-en-ciel, animations |
| Prix | Bon marché | Plus cher |
Pourquoi un MOSFET et lequel choisir ?
Une broche d'Arduino Uno est prévue pour environ 20 mA (limite absolue 40 mA), alors qu'un seul canal d'un ruban 60 LED/m de 5 mètres peut tirer 2 A. De plus, le ruban fonctionne en 12 V. Un MOSFET à canal N règle le problème en interrupteur côté masse : le Drain va à la ligne de couleur du ruban, la Source à la masse, et la tension appliquée sur la Grille ouvre ou ferme le MOSFET. Le point crucial est de choisir un MOSFET logic level ; les MOSFET standard comme l'IRF520 ou l'IRF540N demandent environ 10 V pour s'ouvrir complètement et, à 5 V, ils restent à moitié ouverts et chauffent. La puissance dissipée dans le MOSFET vaut P = I² × Rds(on) : pour 2 A et 0,025 Ω, cela donne 2 × 2 × 0,025 = 0,1 W, donc pas besoin de radiateur. Pour les bases, jette un œil à l'article Utiliser un MOSFET avec Arduino.
| MOSFET | Tension de grille | Rds(on) | Adéquation |
|---|---|---|---|
| IRLZ44N | Logic level, pleinement ouvert à 4–5 V | 0,025 Ω (à 5 V) | Idéal pour Uno et Nano ; à 3,3 V seulement pour de courts rubans |
| IRLB8721 | S'ouvre bien aussi à 3,3 V | Environ 0,009 Ω (à 4,5 V) | L'un des meilleurs choix pour ESP32 et Pico |
| AO3400 (SMD) | S'ouvre à 2,5 V | Environ 0,03 Ω (à 4,5 V) | Petites cartes, 2–3 A par canal |
| IRF520 / IRF540N | Demande environ 10 V | Élevé à 5 V | Déconseillé, chauffe |
Schéma du circuit et tableau de câblage
Tu montes trois fois le même petit circuit, un par canal de couleur. Quand tu tiens l'IRLZ44N avec la face imprimée vers toi, les broches sont, de gauche à droite, Gate, Drain, Source ; tu peux aussi vérifier le brochage avec l'outil transistors. Place une résistance de 220 Ω entre la Gate et la broche de la carte ; elle limite le pic de courant pendant la charge de la capacité de grille. Ajoute aussi une résistance pull-down de 10 kΩ entre la Gate et la masse ; elle empêche le MOSFET de s'ouvrir tout seul et d'allumer le ruban au hasard quand les broches sont flottantes au démarrage ou pendant le téléversement. La règle la plus importante : le moins de l'alimentation 12 V et la masse de la carte doivent absolument être reliés, sinon le signal de grille n'a pas de référence. Nous détaillons ce point dans l'article masse commune.
| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Gate du MOSFET rouge (via 220 Ω) | D9 | GPIO 25 | GP11 |
| Gate du MOSFET vert (via 220 Ω) | D10 | GPIO 26 | GP12 |
| Gate du MOSFET bleu (via 220 Ω) | D11 | GPIO 27 | GP13 |
| Drains des MOSFET | Fils R, G, B du ruban | Fils R, G, B du ruban | Fils R, G, B du ruban |
| Sources des MOSFET | GND | GND | GND |
| Potentiomètre de teinte (broche centrale) | A0 | GPIO 34 | GP26 (ADC0) |
| Potentiomètre de luminosité (broche centrale) | A1 | Non utilisé | Non utilisé |
| Extrémités des potentiomètres | 5V et GND | 3V3 et GND | 3V3 et GND |
| Moins de l'alimentation 12 V | GND | GND | GND |
| Fil +12V du ruban | Plus de l'alimentation | Plus de l'alimentation | Plus de l'alimentation |
Calcul de puissance : quelle alimentation choisir ?
Pour choisir l'alimentation, calcule d'abord le courant du ruban en blanc max : I = mètres × A/m. Un ruban de 5 mètres à 60 LED/m consomme 5 × 1,2 = 6 A ; la puissance, avec P = V × I, vaut 12 × 6 = 72 W. Prends toujours une alimentation avec environ 20 % de marge : ici, une 12 V 8 A (96 W) convient. Pour un ruban 30 LED/m de 2 mètres, qui consomme 1,2 A, une alimentation 12 V 2 A suffit. Choisis aussi le câble selon le courant ; au-delà de 5 A, utilise un câble d'au moins 0,75 mm² plutôt que des fils de test. Si tu veux alimenter la carte avec la même alimentation, la prise jack ou la broche Vin de l'Arduino Uno accepte 12 V et fonctionne sans souci sous faible charge. En revanche, ne branche pas 12 V directement sur les cartes ESP32 ni sur le Pico ; l'entrée VSYS du Pico accepte 5,5 V au maximum. Pour ces cartes, la solution la plus propre est de descendre 12 V à 5 V avec un abaisseur de tension LM2596 et d'alimenter la broche 5V de l'ESP32 ou la broche VSYS du Pico. Tu peux vérifier les calculs avec la calculatrice de loi d'Ohm et lire l'article calcul de la puissance électrique pour plus de détails.
Montage pas à pas
- Monte tout le circuit avant de brancher l'alimentation ; ne modifie jamais une connexion quand le circuit est sous tension.
- Soude quatre fils sur les pastilles du ruban ou utilise un connecteur prêt à l'emploi ; relie le fil +12V au plus de l'alimentation.
- Place les trois MOSFET et relie leurs broches Source à la ligne de masse commune. Les rails d'une breadboard conviennent pour environ 1 A ; pour des rubans de plusieurs ampères, fais passer le courant par des soudures ou un bornier.
- Relie la broche Drain de chaque MOSFET au fil de couleur correspondant du ruban (R, G, B).
- Relie les Gates à D9, D10 et D11 via des résistances de 220 Ω ; ajoute une résistance de 10 kΩ entre chaque Gate et la masse.
- Crée la masse commune en reliant le moins de l'alimentation 12 V à la broche GND d'Arduino.
- Branche l'Arduino à l'ordinateur en USB, téléverse le premier code, puis branche l'alimentation.
- Vérifie que chaque couleur s'allume seule ; si une mauvaise couleur s'allume, permute les numéros de broches dans le code.
Premier code : mélanger les couleurs avec Arduino
Une fois le circuit monté, le plus sûr pour commencer est de tester chaque canal un par un. Le code suivant utilise les broches PWM 9, 10 et 11 de l'Uno et affiche six couleurs à la suite avec la fonction setColor(). Si tu te demandes comment marche le PWM, consulte l'article Qu'est-ce que le PWM.
1const int PIN_R = 9; // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 10; // yeşil MOSFET kapısı / green MOSFET gate
3const int PIN_B = 11; // mavi MOSFET kapısı / blue MOSFET gate
4
5void setColor(uint8_t r, uint8_t g, uint8_t b) {
6 analogWrite(PIN_R, r); // 255 = tam parlak, 0 = sönük / 255 = full, 0 = off
7 analogWrite(PIN_G, g);
8 analogWrite(PIN_B, b);
9}
10
11void setup() {
12 pinMode(PIN_R, OUTPUT);
13 pinMode(PIN_G, OUTPUT);
14 pinMode(PIN_B, OUTPUT);
15 setColor(0, 0, 0); // başlangıçta kapalı / off at start
16}
17
18void loop() {
19 setColor(255, 0, 0); delay(1000); // kırmızı / red
20 setColor(0, 255, 0); delay(1000); // yeşil / green
21 setColor(0, 0, 255); delay(1000); // mavi / blue
22 setColor(255, 120, 0); delay(1000); // turuncu / orange
23 setColor(160, 0, 255); delay(1000); // mor / purple
24 setColor(255, 255, 255); delay(1000); // beyaz / white
25}Il y a ici une différence importante : si tu branches directement une LED RGB à anode commune sur une broche, la logique est inversée (255 l'éteint), mais avec un circuit à MOSFET, analogWrite(pin, 255) ouvre complètement le MOSFET et allume la couleur à pleine luminosité ; 0 l'éteint. Sur l'Uno, les broches 9 et 10 dépendent de Timer1 et la broche 11 de Timer2, et les trois tournent à environ 490 Hz ; à cette fréquence, l'œil ne voit pas de scintillement. En revanche, la fonction tone() utilise Timer2 et perturbe le PWM de la broche 11, et la bibliothèque Servo désactive le PWM des broches 9 et 10. Si ton projet comporte un buzzer ou un servo, planifie les broches en conséquence. Par ailleurs, la luminosité des couleurs du ruban n'est pas équilibrée ; si le blanc paraît bleuté, tu peux le corriger en ramenant le canal bleu vers 200.
Fondu de couleurs lent : roue chromatique avec millis()
Pour que le ruban parcoure doucement toutes les couleurs, on utilise le principe de la roue chromatique : une valeur de teinte entre 0 et 767 est répartie en trois zones. Pendant les 256 premiers pas, le rouge diminue et le vert augmente, puis le vert passe au bleu pendant les 256 suivants, et enfin le bleu repasse au rouge. Comme la somme des deux canaux vaut 255 à chaque pas, les couleurs s'enchaînent sans coupure. Comme nous utilisons millis() à la place de delay(), tu peux aussi lire un bouton ou mesurer un capteur dans loop(). Notre œil ne perçoit pas la luminosité de façon linéaire : de petits changements à faible valeur sont très visibles, alors qu'à forte valeur ils passent presque inaperçus. C'est pourquoi la fonction gamma8() du code met la valeur au carré (v × v / 255) et rend les transitions en lumière faible plus naturelles. Si tu augmentes STEP_MS, le tour complet dure plus longtemps ; avec 15 ms, un tour dure environ 11,5 secondes.
1const int PIN_R = 9; // kırmızı / red
2const int PIN_G = 10; // yeşil / green
3const int PIN_B = 11; // mavi / blue
4
5const unsigned long STEP_MS = 15; // 768 x 15 ms = yaklaşık 11,5 s / about 11.5 s per cycle
6unsigned long lastStep = 0;
7int hue = 0; // renk tonu 0-767 / hue 0-767
8
9uint8_t gamma8(uint8_t v) {
10 return (uint16_t)v * v / 255; // basit gama düzeltmesi / simple gamma correction
11}
12
13void setColor(uint8_t r, uint8_t g, uint8_t b) {
14 analogWrite(PIN_R, gamma8(r));
15 analogWrite(PIN_G, gamma8(g));
16 analogWrite(PIN_B, gamma8(b));
17}
18
19void wheel(int h) {
20 uint8_t p = h % 256;
21 if (h < 256) setColor(255 - p, p, 0); // kırmızı -> yeşil / red -> green
22 else if (h < 512) setColor(0, 255 - p, p); // yeşil -> mavi / green -> blue
23 else setColor(p, 0, 255 - p); // mavi -> kırmızı / blue -> red
24}
25
26void setup() {
27 pinMode(PIN_R, OUTPUT);
28 pinMode(PIN_G, OUTPUT);
29 pinMode(PIN_B, OUTPUT);
30}
31
32void loop() {
33 if (millis() - lastStep >= STEP_MS) {
34 lastStep = millis();
35 wheel(hue);
36 hue = (hue + 1) % 768;
37 }
38 // burada buton ya da sensör okuyabilirsin / you can read buttons or sensors here
39}Choisir couleur et luminosité avec des potentiomètres
Pour choisir la couleur à la main, deux potentiomètres suffisent : celui sur A0 détermine la teinte (0–767) et celui sur A1 la luminosité globale (0–255). Comme analogRead() renvoie une valeur de 0 à 1023, on la met à l'échelle voulue avec map(). La luminosité s'applique en multipliant chaque canal par bri / 255 ; la teinte est ainsi conservée pendant que la lumière baisse. Il est aussi possible de régler R, G et B directement avec trois potentiomètres, mais la roue chromatique à un seul bouton est bien plus intuitive et te permet d'atteindre toutes les couleurs saturées, sauf le blanc.
1const int PIN_R = 9;
2const int PIN_G = 10;
3const int PIN_B = 11;
4const int POT_HUE = A0; // renk tonu / hue
5const int POT_BRI = A1; // parlaklık / brightness
6
7void setup() {
8 pinMode(PIN_R, OUTPUT);
9 pinMode(PIN_G, OUTPUT);
10 pinMode(PIN_B, OUTPUT);
11}
12
13void loop() {
14 int hue = map(analogRead(POT_HUE), 0, 1023, 0, 767);
15 int bri = map(analogRead(POT_BRI), 0, 1023, 0, 255);
16
17 uint8_t r, g, b;
18 uint8_t p = hue % 256;
19 if (hue < 256) { r = 255 - p; g = p; b = 0; } // kırmızı -> yeşil / red -> green
20 else if (hue < 512) { r = 0; g = 255 - p; b = p; } // yeşil -> mavi / green -> blue
21 else { r = p; g = 0; b = 255 - p; } // mavi -> kırmızı / blue -> red
22
23 analogWrite(PIN_R, (uint16_t)r * bri / 255); // parlaklığı uygula / apply brightness
24 analogWrite(PIN_G, (uint16_t)g * bri / 255);
25 analogWrite(PIN_B, (uint16_t)b * bri / 255);
26 delay(20);
27}Contrôler un ruban RGB avec l'ESP32 (LEDC)
Sur l'ESP32, le PWM passe par l'unité matérielle LEDC ; c'est toi qui fixes la fréquence et la résolution. 5 kHz et 8 bits donnent une lumière sans scintillement et la plage familière 0–255. Avec le core Arduino 3.x, on utilise ledcAttach(pin, fréquence, résolution) et ledcWrite(pin, valeur), alors qu'avec le 2.x on crée d'abord un canal avec ledcSetup(), on le relie à la broche avec ledcAttachPin() et ledcWrite() écrit sur le canal ; le code ci-dessous gère les deux versions avec #if. Comme les broches de l'ESP32 sortent du 3,3 V, il est important de choisir un MOSFET à faible tension de grille comme l'IRLB8721 du tableau. Nous avons branché le potentiomètre sur GPIO 34, une broche ADC1 qui fonctionne aussi avec le Wi-Fi activé ; l'ADC fait 12 bits, donc les valeurs vont de 0 à 4095, et on fait la moyenne de huit lectures pour réduire le bruit. Pour les bases de la carte, consulte l'article Qu'est-ce que l'ESP32.
1const int PIN_R = 25; // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 26; // yeşil / green
3const int PIN_B = 27; // mavi / blue
4const int POT_HUE = 34; // ADC1, yalnız giriş / ADC1, input only
5const int PWM_FREQ = 5000; // 5 kHz, titreşimsiz / flicker-free
6const int PWM_RES = 8; // 8 bit: 0-255
7
8void setColor(uint8_t r, uint8_t g, uint8_t b) {
9#if ESP_ARDUINO_VERSION_MAJOR >= 3
10 ledcWrite(PIN_R, r); // core 3.x: pine yaz / write to pin
11 ledcWrite(PIN_G, g);
12 ledcWrite(PIN_B, b);
13#else
14 ledcWrite(0, r); // core 2.x: kanala yaz / write to channel
15 ledcWrite(1, g);
16 ledcWrite(2, b);
17#endif
18}
19
20void setup() {
21#if ESP_ARDUINO_VERSION_MAJOR >= 3
22 ledcAttach(PIN_R, PWM_FREQ, PWM_RES);
23 ledcAttach(PIN_G, PWM_FREQ, PWM_RES);
24 ledcAttach(PIN_B, PWM_FREQ, PWM_RES);
25#else
26 ledcSetup(0, PWM_FREQ, PWM_RES);
27 ledcSetup(1, PWM_FREQ, PWM_RES);
28 ledcSetup(2, PWM_FREQ, PWM_RES);
29 ledcAttachPin(PIN_R, 0);
30 ledcAttachPin(PIN_G, 1);
31 ledcAttachPin(PIN_B, 2);
32#endif
33 analogReadResolution(12); // 0-4095
34 setColor(0, 0, 0);
35}
36
37void loop() {
38 long sum = 0;
39 for (int i = 0; i < 8; i++) {
40 sum += analogRead(POT_HUE); // 8 okumayı topla / sum 8 readings
41 }
42 int hue = map(sum / 8, 0, 4095, 0, 767);
43 uint8_t p = hue % 256;
44 if (hue < 256) setColor(255 - p, p, 0); // kırmızı -> yeşil / red -> green
45 else if (hue < 512) setColor(0, 255 - p, p); // yeşil -> mavi / green -> blue
46 else setColor(p, 0, 255 - p); // mavi -> kırmızı / blue -> red
47 delay(20);
48}Code MicroPython avec le Raspberry Pi Pico
Sur le Pico, chaque broche GPIO peut produire du PWM et duty_u16() accepte une valeur de 0 à 65535. Dans le code, on convertit les valeurs de couleur 0–255 vers cette plage en les multipliant par 257 (255 × 257 = 65535). Le potentiomètre est branché sur GP26 (ADC0) ; comme read_u16() renvoie aussi 0–65535, la conversion en teinte est facile. GP12 et GP13 partagent la même tranche PWM (slice 6) ; comme nous leur donnons la même fréquence, il n'y a aucun problème, mais si tu essaies de régler des fréquences différentes, le dernier réglage affecte les deux. Comme le Pico fonctionne en 3,3 V, la recommandation de MOSFET donnée pour l'ESP32 s'applique aussi ici. Pour la mise en route, lis l'article Qu'est-ce que le Raspberry Pi Pico.
1from machine import Pin, PWM, ADC
2import time
3
4pins = (11, 12, 13) # R, G, B MOSFET kapıları / gates
5leds = []
6for p in pins:
7 pwm = PWM(Pin(p))
8 pwm.freq(1000) # 1 kHz PWM
9 pwm.duty_u16(0) # başlangıçta kapalı / off at start
10 leds.append(pwm)
11
12pot = ADC(26) # GP26 = ADC0
13
14def set_color(r, g, b):
15 # 0-255 değerini 0-65535'e çevir / convert 0-255 to 0-65535
16 leds[0].duty_u16(r * 257)
17 leds[1].duty_u16(g * 257)
18 leds[2].duty_u16(b * 257)
19
20def wheel(hue):
21 p = hue % 256
22 if hue < 256:
23 return 255 - p, p, 0 # kırmızı -> yeşil / red -> green
24 elif hue < 512:
25 return 0, 255 - p, p # yeşil -> mavi / green -> blue
26 return p, 0, 255 - p # mavi -> kırmızı / blue -> red
27
28while True:
29 hue = pot.read_u16() * 767 // 65535 # 0-767 ton / hue
30 set_color(*wheel(hue))
31 time.sleep_ms(20)Idées de projets avec un ruban LED RGB
- Ambiance sensible à la musique : avec un capteur de son, fais varier la couleur et la luminosité du ruban au rythme de la musique ; les détails sont dans l'article LED sensible à la musique.
- Rétroéclairage de TV avec télécommande : change la couleur et la luminosité depuis le canapé avec un récepteur IR et une télécommande.
- Éclairage d'escalier à détection de mouvement : quand le capteur PIR détecte quelqu'un, allume le ruban progressivement et éteins-le au bout d'un moment.
- Veilleuse automatique : quand la pièce s'assombrit, une LDR déclenche un orange chaud à faible luminosité.
- Commande depuis le téléphone : monte un serveur web sur l'ESP32 et utilise un sélecteur de couleur dans le navigateur.
- Réveil lumineux : 20 minutes avant l'heure du réveil, allume doucement le ruban du rouge sombre vers le blanc.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Le ruban ne s'allume pas du tout | Pas de masse commune ou fil +12V non branché | Relie le moins de l'alimentation à la masse de la carte, vérifie le fil +12V du ruban |
| Une couleur reste allumée quoi que dise le code | Drain et Source du MOSFET inversés ou MOSFET grillé | Vérifie l'ordre des broches (G-D-S), remplace le MOSFET si besoin |
| Le ruban clignote tout seul au démarrage | Pas de résistance pull-down sur la Gate | Ajoute 10 kΩ entre chaque Gate et la masse |
| Le MOSFET chauffe beaucoup | MOSFET non logic level ou tension de grille insuffisante à 3,3 V | Utilise un MOSFET logic level comme l'IRLZ44N ou l'IRLB8721 |
| Couleurs mélangées (vert au lieu de rouge) | Étiquettes du ruban ou ordre des fils différents | Permute les valeurs PIN_R, PIN_G, PIN_B dans le code |
| Le bout du ruban est jaunâtre et faible | Chute de tension sur un long ruban | Alimente les rubans de plus de 5 m par les deux bouts, utilise un câble épais |
| La carte se réinitialise ou redémarre | Alimentation insuffisante, la tension s'effondre | Utilise une alimentation plus puissante, alimente la carte par un régulateur séparé |
| Scintillement ou lignes sur la caméra | Fréquence PWM trop basse | Monte la fréquence à 1–5 kHz sur ESP32 et Pico |
Un ruban RGB non adressable, trois MOSFET et trois broches PWM, c'est le moyen le plus pratique d'ajouter une couche de lumière puissante et peu chère à ta chambre, ton bureau ou ton projet. Si tu veux contrôler chaque LED séparément, le WS2812B peut être la prochaine étape. Dans l'application BlueGrays, tu retrouves pas à pas, avec schéma et code, les projets de mélange de couleurs avec LED RGB, de fondu fluide, de lampe mélangeuse de couleurs ESP32 et de cycle de couleurs RGB sur Pico.
Questions fréquentes
Peut-on brancher un ruban LED RGB directement sur Arduino ?
Non. Un ruban 12 V peut consommer plus d'un ampère par mètre, alors qu'une broche d'Arduino fournit environ 20 mA et travaille en 5 V. Tu dois piloter le ruban avec un MOSFET logic level par canal de couleur ; Arduino envoie seulement un signal PWM sur la grille du MOSFET.
Quel MOSFET utiliser pour un ruban LED 12 V ?
Pour les Arduino Uno et Nano en 5 V, l'IRLZ44N est un choix courant et adapté. Pour les cartes 3,3 V comme l'ESP32 et le Raspberry Pi Pico, des MOSFET qui s'ouvrent complètement avec une faible tension de grille, comme l'IRLB8721 ou l'AO3400, donnent de meilleurs résultats. L'IRF520 et l'IRF540N ne s'ouvrent pas complètement à 5 V et chauffent.
Combien d'ampères consomme un ruban LED RGB de 5 mètres ?
Un ruban 5050 de 60 LED/m consomme environ 1,2 A par mètre en blanc max ; 5 mètres font environ 6 A et 72 W. Avec un ruban 30 LED/m, ces valeurs sont divisées par deux. Choisis l'alimentation avec 20 % de marge ; pour 6 A, une alimentation 12 V 8 A convient.
Quelle est la différence entre un ruban RGB et un WS2812B ?
Sur un ruban RGB non adressable, toutes les LED affichent la même couleur en même temps et se pilotent avec trois MOSFET. Sur le WS2812B, chaque LED a sa propre puce de pilotage et une seule broche de données envoie une couleur différente à chaque LED. Le WS2812B est idéal pour les effets de défilement, le ruban RGB pour un éclairage uni, bon marché et puissant.
Où peut-on couper un ruban LED RGB ?
Les rubans 12 V fonctionnent par segments de trois LED et ne se coupent qu'aux repères de découpe situés sur les pastilles de cuivre ; ce pas est de 5 cm à 60 LED/m et de 10 cm à 30 LED/m. Si tu coupes ailleurs, ce segment ne s'allumera pas. Tu peux reconnecter la partie coupée en soudant des fils sur les pastilles ou avec un connecteur à clipser.
Puis-je alimenter l'Arduino avec l'alimentation 12 V du ruban ?
Tu peux alimenter l'Arduino Uno en 12 V par la prise jack ou la broche Vin ; le régulateur de la carte le supporte sous faible charge. Pour les cartes ESP32 et le Raspberry Pi Pico, tu dois abaisser 12 V à 5 V avec un abaisseur comme le LM2596. Dans tous les cas, le moins de l'alimentation doit être relié à la masse de la carte.
Projets à réaliser après cet article
Voir tous les projets
Utilisation d'une LED RVB
Trois couleurs se cachent dans une seule LED : la LED RGB s'allume en rouge, puis en vert, puis en bleu, chaque couleur allumée une demi-seconde puis éteinte une demi-seconde, avant que tout…

Transition douce des couleurs avec une LED RVB
Une seule LED RGB glisse doucement du rouge au vert, du vert au bleu, puis revient au rouge, dans une boucle arc-en-ciel qui ne s'arrête jamais.

Contrôle d'une LED RVB avec ESP32
Génération illimitée de couleurs avec une seule LED RVB au lieu de 3 LED séparées. Comme dans Arduino, nous réalisons une transition arc-en-ciel en réglant les valeurs R/G/B avec analogWrite(). La théorie des couleurs (telle que rouge+vert=jaune) est mise en pratique.

Lampe à mélangeur de couleurs ESP32 (3 potentiomètres + LED RVB + écran OLED)
Une lampe mélangeuse de couleurs intelligente : tourne 3 potentiomètres sur l'ESP32 et mélange la couleur de ton choix ! Quand tu tournes les potentiomètres rouge, vert et bleu, la LED RGB à cathode commune change de couleur aussitôt. L'écran OLED SSD1306 affiche en direct la valeur 0-255 de chaque couleur, des barres de remplissage et le code couleur web HEX (comme #FF8040).

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.

ESP32 LED Fade avec PWM
Modifiez la luminosité de la LED en douceur de 0 à max, de max à 0. Nous contrôlons le PWM avec analogWrite() comme dans Arduino - la même syntaxe avec ESP32 Arduino Core 3.0+ fonctionne sans problème. La définition du pin + pinMode + analogWrite est suffisante.

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

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.
Autres articles
- MOSFET Arduino : piloter ruban LED, moteur et pompe en 12 V
- Qu'est-ce que le PWM ? Guide d'analogWrite, du rapport cyclique et de la fréquence sur Arduino
- Utiliser une LED RGB : mélanger les couleurs avec Arduino, anode ou cathode commune
- Ruban LED WS2812B NeoPixel avec Arduino : guide des LED RGB adressables
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

