Utiliser une LED RGB : mélanger les couleurs avec Arduino, anode ou cathode commune

Une LED RGB, ce sont trois LED distinctes dans un même boîtier : rouge (Red), verte (Green) et bleue (Blue). En réglant la luminosité de chacune séparément, tu obtiens presque n'importe quelle couleur, du jaune au turquoise et du violet à l'orange. Chaque pixel d'un écran fonctionne de la même façon. C'est l'un des composants Arduino les plus amusants pour les voyants d'état, les lampes d'ambiance et les indicateurs de notification colorés.

Comment fonctionne une LED RGB ?

Les couleurs de la lumière se mélangent par addition : rouge et vert ensemble donnent du jaune à l'œil, vert et bleu du turquoise (cyan), rouge et bleu du violet (magenta), et les trois ensemble du blanc. L'Arduino règle la luminosité de chaque canal de 0 à 255 grâce à la MLI (PWM). On obtient ainsi, en théorie, 256 × 256 × 256 ≈ 16,7 millions de combinaisons. Le PWM allume et éteint la LED des centaines de fois par seconde ; l'œil ne perçoit pas ce clignotement, seulement la luminosité moyenne.

Cathode commune ou anode commune ?

La plus longue des quatre pattes est la broche commune aux trois LED. Si elle relie leurs cathodes, la LED est à cathode commune ; si elle relie leurs anodes, elle est à anode commune. De l'extérieur elles sont identiques, mais câblage et code sont inversés :

Ordre des pattes et câblage sur Arduino

Sur les LED RGB 5 mm courantes, l'ordre est rouge, commune (la plus longue), vert, bleu, mais il peut varier selon le fabricant : le plus sûr est de tester chaque patte. Chaque couleur se branche via sa propre résistance sur une broche PWM. Sur l'Arduino Uno, ce sont les broches marquées ~ : 3, 5, 6, 9, 10 et 11.

Calcul des résistances : une par couleur

Chaque couleur a besoin d'une tension différente pour s'allumer (tension directe) : environ 2,0 V pour le rouge et 3,0–3,2 V pour le vert et le bleu. Pour 20 mA sous 5 V, le rouge demande (5 − 2,0) / 0,020 = 150 Ω et le vert et le bleu (5 − 3,2) / 0,020 ≈ 100 Ω. En pratique, mettre 220 Ω sur les trois est sûr et reste assez lumineux ; l'équilibre des couleurs se règle dans le code. Pour calculer tes propres valeurs, utilise le calculateur Résistance de LED, et pour la tension directe de chaque couleur, le tableau Tensions des LED.

Mélanger les couleurs avec Arduino

Le code ci-dessous regroupe les trois canaux dans une seule fonction setColor() et affiche sept couleurs à la suite. Si ta LED est à anode commune, il suffit de passer COMMON_ANODE à true ; la fonction inverse les valeurs toute seule.

1const int R_PIN = 9;
2const int G_PIN = 10;
3const int B_PIN = 11;
4const bool COMMON_ANODE = false;   // ortak anotsa true yap / set true for common anode
5
6void setColor(int r, int g, int b) {
7  if (COMMON_ANODE) { r = 255 - r; g = 255 - g; b = 255 - b; }
8  analogWrite(R_PIN, r);
9  analogWrite(G_PIN, g);
10  analogWrite(B_PIN, b);
11}
12
13void setup() {
14  pinMode(R_PIN, OUTPUT);
15  pinMode(G_PIN, OUTPUT);
16  pinMode(B_PIN, OUTPUT);
17}
18
19void loop() {
20  setColor(255, 0, 0);     delay(1000);  // kırmızı / red
21  setColor(0, 255, 0);     delay(1000);  // yeşil / green
22  setColor(0, 0, 255);     delay(1000);  // mavi / blue
23  setColor(255, 255, 0);   delay(1000);  // sarı / yellow
24  setColor(0, 255, 255);   delay(1000);  // turkuaz / cyan
25  setColor(255, 0, 255);   delay(1000);  // mor / magenta
26  setColor(255, 255, 255); delay(1000);  // beyaz / white
27}

Transition douce : l'effet arc-en-ciel

Au lieu de sauter d'une couleur à l'autre, baisse un canal tout en montant un autre : la lumière glisse en douceur du rouge au vert, du vert au bleu, puis revient au rouge. La boucle ci-dessous utilise la même fonction setColor() ; modifie la valeur de delay pour régler la vitesse.

1// setColor() ve pin tanımları yukarıdaki gibi / setColor() and pins as above
2void loop() {
3  for (int i = 0; i < 256; i++) { setColor(255 - i, i, 0); delay(8); }  // kırmızı → yeşil / red → green
4  for (int i = 0; i < 256; i++) { setColor(0, 255 - i, i); delay(8); }  // yeşil → mavi / green → blue
5  for (int i = 0; i < 256; i++) { setColor(i, 0, 255 - i); delay(8); }  // mavi → kırmızı / blue → red
6}

Choisir la couleur avec des potentiomètres

Si tu branches trois potentiomètres sur A0, A1 et A2, chacun devient le bouton d'un canal de couleur. analogRead() renvoie une valeur de 0 à 1023 ; en la divisant par 4, on obtient la plage 0–255 attendue par le PWM. Le branchement d'un potentiomètre est expliqué dans Qu'est-ce qu'un potentiomètre ?

1// A0, A1, A2'de üç potansiyometre; setColor() yukarıdaki gibi
2// three pots on A0, A1, A2; setColor() as above
3void loop() {
4  int r = analogRead(A0) / 4;   // 0–1023 → 0–255
5  int g = analogRead(A1) / 4;
6  int b = analogRead(A2) / 4;
7  setColor(r, g, b);
8}

LED RGB avec l'ESP32 et le Raspberry Pi Pico

Sur l'ESP32, avec le cœur Arduino actuel (3.x), analogWrite() fonctionne sur toutes les broches de sortie : le code ci-dessus marche tel quel en changeant les numéros de broche. Seule la tension demande de l'attention : les broches délivrent 3,3 V, donc le vert et le bleu, dont la tension directe approche 3 V, éclairent moins. En 3,3 V, utilise de petites résistances de 47 à 100 Ω, ou commande la LED en 5 V via un transistor si tu veux beaucoup de lumière. Sur le Pico, la classe PWM de MicroPython accepte des valeurs de 0 à 65535 :

1from machine import Pin, PWM
2import time
3
4pins = [PWM(Pin(n)) for n in (11, 12, 13)]   # GP11 R, GP12 G, GP13 B
5for p in pins:
6    p.freq(1000)
7
8def set_color(r, g, b):                       # 0–255
9    for p, v in zip(pins, (r, g, b)):
10        p.duty_u16(v * 257)                   # 0–65535 (ortak anotta 65535 - v * 257)
11
12while True:
13    set_color(255, 0, 0); time.sleep(1)       # kırmızı / red
14    set_color(0, 255, 0); time.sleep(1)       # yeşil / green
15    set_color(0, 0, 255); time.sleep(1)       # mavi / blue

LED RGB classique ou LED adressable (WS2812B) ?

Pour une ou deux lumières colorées, la LED RGB classique est la solution la plus simple et la moins chère. Pour colorer des dizaines de LED individuellement, les 6 broches PWM de l'Uno ne suffisent pas ; il faut alors passer aux rubans WS2812B, qui pilotent des centaines de LED sur un seul fil.

Idées de projets avec une LED RGB

• Lampe d'ambiance : place l'effet arc-en-ciel dans un bocal dépoli pour une veilleuse douce.
• Indicateur de température : associe-la à un DHT11 pour une lampe bleue quand il fait froid, verte quand c'est tempéré et rouge quand il fait chaud.
• Mélangeur de couleurs : crée n'importe quelle couleur à la main avec trois potentiomètres.
• Choisir la couleur depuis le téléphone : change la couleur de la lampe depuis un sélecteur de couleur sur une page web servie par un ESP32.
• Voyant de notification : fais clignoter la LED dans une couleur précise à l'arrivée d'un e-mail ou d'un message.
• Couleurs au clavier : affiche une couleur différente selon le chiffre tapé sur un clavier matriciel.

Erreurs fréquentes et solutions

• Les couleurs fonctionnent à l'envers : tu pilotes une LED à anode commune comme une LED à cathode commune ; passe COMMON_ANODE à true.
• Une couleur ne s'allume jamais : l'ordre des pattes est peut-être différent de ce que tu pensais ; teste chaque patte avec une résistance.
• Les transitions se font par paliers, sans nuances : la LED est sur une broche sans PWM ; sur l'Uno, ces broches ne peuvent être qu'allumées ou éteintes.
• Les couleurs déraillent quand un buzzer joue : sur l'Uno, tone() utilise le Timer2 et perturbe le PWM des broches 3 et 11 ; déplace la LED RGB sur les broches 5, 6, 9 et 10.
• Oublier les résistances : un courant trop fort finit par abîmer la LED et la broche de l'Arduino.
• Très faible sur l'ESP32 : en 3,3 V, le vert et le bleu sont à la limite ; utilise des résistances plus petites ou un transistor.

Pour comprendre les bases des LED et pourquoi elles ont besoin de résistances, jette un œil à Qu'est-ce qu'une LED ? et Qu'est-ce qu'une résistance ? Dans l'application BlueGrays, tu trouveras des projets de dégradé de couleurs avec LED RGB, de lampe pilotée au clavier et de mélangeur de couleurs, avec schémas et code.