Guides · 11 min de lecture

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éristiqueRuban 30 LED/mRuban 60 LED/m
Type de LED5050 SMD (5,0 × 5,0 mm, 3 puces)5050 SMD (5,0 × 5,0 mm, 3 puces)
Tension de fonctionnement12 V DC12 V DC
Puissance (blanc max)Environ 7,2 W/mEnviron 14,4 W/m
Courant (blanc max)Environ 0,6 A/mEnviron 1,2 A/m
Courant par canalEnviron 0,2 A/mEnviron 0,4 A/m
Pas de découpeToutes 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éristiqueRuban RGB 12 V (5050)Ruban WS2812B
CommandeTout le ruban d'une seule couleurUne couleur par LED
Alimentation12 V (versions 24 V aussi)5 V
Câblage4 fils : +12V, R, G, B3 fils : 5V, DIN, GND
Circuit de puissanceUn MOSFET par canalInutile, une seule broche de données suffit
CodeanalogWrite / PWMBibliothè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 tensionRarement un problème jusqu'à 5 mAlimentation en plusieurs points sur les longs rubans
EffetsCouleur fixe, fondu, respirationDéfilement, arc-en-ciel, animations
PrixBon 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.

MOSFETTension de grilleRds(on)Adéquation
IRLZ44NLogic level, pleinement ouvert à 4–5 V0,025 Ω (à 5 V)Idéal pour Uno et Nano ; à 3,3 V seulement pour de courts rubans
IRLB8721S'ouvre bien aussi à 3,3 VEnviron 0,009 Ω (à 4,5 V)L'un des meilleurs choix pour ESP32 et Pico
AO3400 (SMD)S'ouvre à 2,5 VEnviron 0,03 Ω (à 4,5 V)Petites cartes, 2–3 A par canal
IRF520 / IRF540NDemande environ 10 VÉlevé à 5 VDéconseillé, chauffe
Ne branche jamais un fil R, G ou B du ruban directement sur une broche d'Arduino, et ne relie en aucun cas le fil +12V au 5V ou aux broches de signal d'Arduino. Si 12 V atteignent une broche, le microcontrôleur grille immédiatement. Pendant le montage, débranche l'alimentation et ne la rebranche qu'après avoir vérifié les connexions.

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.

ConnexionArduino UnoESP32Raspberry Pi Pico
Gate du MOSFET rouge (via 220 Ω)D9GPIO 25GP11
Gate du MOSFET vert (via 220 Ω)D10GPIO 26GP12
Gate du MOSFET bleu (via 220 Ω)D11GPIO 27GP13
Drains des MOSFETFils R, G, B du rubanFils R, G, B du rubanFils R, G, B du ruban
Sources des MOSFETGNDGNDGND
Potentiomètre de teinte (broche centrale)A0GPIO 34GP26 (ADC0)
Potentiomètre de luminosité (broche centrale)A1Non utiliséNon utilisé
Extrémités des potentiomètres5V et GND3V3 et GND3V3 et GND
Moins de l'alimentation 12 VGNDGNDGND
Fil +12V du rubanPlus de l'alimentationPlus de l'alimentationPlus 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

  1. Monte tout le circuit avant de brancher l'alimentation ; ne modifie jamais une connexion quand le circuit est sous tension.
  2. 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.
  3. 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.
  4. Relie la broche Drain de chaque MOSFET au fil de couleur correspondant du ruban (R, G, B).
  5. 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.
  6. Crée la masse commune en reliant le moins de l'alimentation 12 V à la broche GND d'Arduino.
  7. Branche l'Arduino à l'ordinateur en USB, téléverse le premier code, puis branche l'alimentation.
  8. 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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ômeCause probableSolution
Le ruban ne s'allume pas du toutPas 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 codeDrain 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émarragePas de résistance pull-down sur la GateAjoute 10 kΩ entre chaque Gate et la masse
Le MOSFET chauffe beaucoupMOSFET non logic level ou tension de grille insuffisante à 3,3 VUtilise 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érentsPermute les valeurs PIN_R, PIN_G, PIN_B dans le code
Le bout du ruban est jaunâtre et faibleChute de tension sur un long rubanAlimente les rubans de plus de 5 m par les deux bouts, utilise un câble épais
La carte se réinitialise ou redémarreAlimentation insuffisante, la tension s'effondreUtilise une alimentation plus puissante, alimente la carte par un régulateur séparé
Scintillement ou lignes sur la caméraFréquence PWM trop basseMonte 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.

Voir tous les projets
Utilisation d'une LED RVB
AR-39Débutant
Premium

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…

4.9(73)
100
Transition douce des couleurs avec une LED RVB
AR-40Débutant
Premium

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.

4.8(58)
78
Contrôle d'une LED RVB avec ESP32
ES-9Débutant

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.

4.6(29)
52
Lampe à mélangeur de couleurs ESP32 (3 potentiomètres + LED RVB + écran OLED)
ES-36Avancé
Premium

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

4.7(6)
10
Raspberry Pi Pico LED RVB Cycle de Couleurs (PWM 3 Canaux)
PI-15Débutant

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.

6
ESP32 LED Fade avec PWM
ES-8Débutant

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.

4.8(36)
55
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

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.

4.5(19)
32
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

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.

4