ESP32 LED RGB WiFi : choisir la couleur depuis ton téléphone
Pilote une LED RGB avec l'ESP32 en WiFi grâce au sélecteur de couleur du téléphone : anode et cathode commune, HEX vers RGB, PWM LEDC, gamma et ruban WS2812B.
Pour piloter une LED RGB avec l'ESP32 en WiFi, pas besoin d'installer d'application : l'ESP32 héberge une petite page web, tu choisis une teinte dans le sélecteur de couleur qui s'ouvre dans le navigateur de ton téléphone et la LED change aussitôt. En coulisses, trois choses se passent : le navigateur transforme ton choix en code HEX comme #FF8800 et l'envoie par WiFi, l'ESP32 découpe ce code en trois nombres pour le rouge, le vert et le bleu, puis chaque nombre devient un signal PWM produit par le périphérique LEDC.
Dans ce guide, tu vas apprendre à brancher une LED RGB à cathode commune ou à anode commune sur l'ESP32, à choisir les bonnes résistances pour 3,3 V, à écrire du code LEDC qui fonctionne aussi bien avec le core Arduino ESP32 2.x qu'avec le 3.x, à convertir du HEX en RGB et à appliquer la correction gamma pour que les couleurs ressemblent à ce que voit ton œil. Pour finir, tu brancheras la même interface sur un ruban LED WS2812B sans modifier une seule ligne de HTML.

Comment ça marche ? Du sélecteur de couleur à la LED
- Ton téléphone étant sur le même réseau WiFi que l'ESP32, tu ouvres l'adresse IP de l'ESP32 dans le navigateur et il te renvoie une petite page HTML avec un sélecteur de couleur.
- L'élément <input type="color"> de la page ouvre le sélecteur de couleur du téléphone et renvoie le choix au format #ff8800.
- Quelques lignes de JavaScript envoient cette valeur à l'adresse /set?hex=ff8800 ; pendant que tu fais glisser ton doigt, les nouvelles couleurs partent les unes après les autres.
- L'ESP32 découpe les six chiffres en trois nombres, 255, 136 et 0, et applique la correction gamma à chacun.
- Le LEDC produit un PWM à 5 kHz sur trois broches ; le rapport cyclique fixe la luminosité de chaque couleur et ton œil mélange les trois lumières en une seule teinte.
Matériel
- Carte de développement ESP32 DevKit (30 ou 38 broches)
- Une LED RGB (5 mm, cathode commune ou anode commune)
- Une résistance de 150 Ω pour le rouge et deux de 100 Ω pour le vert et le bleu (à défaut, trois de 220 Ω font l'affaire)
- Une breadboard (plaque d'essai) et quelques fils de connexion
- Un câble USB qui transmet les données
- En option : ruban LED WS2812B, alimentation 5 V, résistance de 330 Ω et condensateur de 1000 µF
Cathode commune ou anode commune : tableau de câblage
Sur les LED RGB à quatre pattes, la plus longue est la commune. Sur une LED à cathode commune (CC), elle va au GND et tu allumes une couleur en mettant sa broche à HIGH. Sur une LED à anode commune (CA), la patte commune va à la tension d'alimentation et la couleur s'allume quand sa broche est à LOW. Si tu ne sais pas laquelle tu as, relie la patte la plus longue au GND et une autre patte au 3V3 à travers une résistance de 150 Ω : si elle s'allume, c'est une cathode commune. Sinon, inverse le branchement ; si elle s'allume maintenant, c'est une anode commune. Sur la plupart des modèles, l'ordre des pattes en partant du côté plat est rouge, commune, vert, bleu.
| Patte | Cathode commune (CC) | Anode commune (CA) | Résistance |
|---|---|---|---|
| Rouge (R) | GPIO 25 | GPIO 25 | 150 Ω |
| Patte commune (la plus longue) | GND | 3V3 | Aucune |
| Vert (G) | GPIO 26 | GPIO 26 | 100 Ω |
| Bleu (B) | GPIO 27 | GPIO 27 | 100 Ω |
| Réglage dans le code | COMMON_ANODE = false | COMMON_ANODE = true | Aucune |
| Rapport cyclique pour une couleur au maximum | 1023 (le maximum) | 0 (le code l'inverse tout seul) | Aucune |
Le calcul de la résistance est une application directe de la loi d'Ohm : R = (3,3 V − tension de la LED) / courant. Une LED rouge demande environ 2,0 V ; avec 150 Ω, le courant vaut (3,3 − 2,0) / 150 ≈ 8,7 mA. Les LED verte et bleue fonctionnent vers 2,8 à 3,1 V, il reste donc très peu de marge à 3,3 V ; avec 100 Ω, il passe 3 à 5 mA et les couleurs sont assez lumineuses. Avec 220 Ω sur les trois pattes, le montage fonctionne, mais le bleu et le vert sont nettement plus faibles et le blanc vire au rose. Pour calculer avec les valeurs de ta propre LED, utilise le calculateur de résistance pour LED. Ne tire pas plus de 20 mA en continu sur une broche de l'ESP32.
PWM LEDC de l'ESP32 : trois canaux, 5 kHz, 10 bits
Sur l'ESP32, l'équivalent du analogWrite de l'Arduino Uno est le périphérique LEDC. L'ESP32 classique possède 16 canaux PWM indépendants, et tu choisis la fréquence et la résolution de chacun. Ce projet utilise 5 kHz et 10 bits : 10 bits signifie que le rapport cyclique va de 0 à 1023, ce qui donne des transitions bien plus douces qu'en 8 bits, surtout dans les tons sombres. 5 kHz est assez rapide pour que ni ton œil ni la plupart des caméras de téléphone ne voient de scintillement. Seul point de vigilance : les fonctions LEDC ont changé dans la version 3.0 du core Arduino ESP32, c'est pourquoi beaucoup d'anciens codes trouvés sur Internet ne compilent plus sur une installation récente. Les croquis ci-dessous testent la constante ESP_ARDUINO_VERSION_MAJOR et fonctionnent sur les deux versions. Pour les bases, vois le guide qu'est-ce que le PWM.
| Version du core | Configuration | Écrire la valeur |
|---|---|---|
| 3.x (actuelle) | ledcAttach(pin, 5000, 10) | ledcWrite(pin, duty) |
| 2.x (ancienne) | ledcSetup(canal, 5000, 10) et ledcAttachPin(pin, canal) | ledcWrite(canal, duty) |
Teste d'abord le câblage
Vérifier le câblage avant de passer au serveur web te fait gagner du temps. Téléverse le croquis ci-dessous : la LED doit s'allumer en rouge, vert, bleu puis blanc pendant une seconde chacun, puis s'éteindre une seconde. Si les couleurs arrivent dans un autre ordre (du vert au lieu du rouge, par exemple), change l'ordre du tableau PINS. Si la LED reste allumée en permanence et s'éteint pile sur le blanc, ta LED est à anode commune ; mets COMMON_ANODE à true.
1// RGB LED bağlantı testi: kırmızı, yeşil, mavi, beyaz, kapalı
2// RGB LED wiring test: red, green, blue, white, off
3const int PINS[3] = {25, 26, 27}; // R, G, B pinleri / R, G, B pins
4const bool COMMON_ANODE = false; // ortak anot ise true / true for common anode
5const int PWM_FREQ = 5000; // 5 kHz, titreme yok / 5 kHz, no flicker
6const int PWM_BITS = 10; // 0-1023
7const int PWM_MAX = (1 << PWM_BITS) - 1;
8
9void pwmSetup() {
10 for (int i = 0; i < 3; i++) {
11#if ESP_ARDUINO_VERSION_MAJOR >= 3
12 ledcAttach(PINS[i], PWM_FREQ, PWM_BITS); // çekirdek 3.x: pin tabanlı / core 3.x: pin based
13#else
14 ledcSetup(i, PWM_FREQ, PWM_BITS); // çekirdek 2.x: kanal i / core 2.x: channel i
15 ledcAttachPin(PINS[i], i);
16#endif
17 }
18}
19
20void pwmWrite(int i, int duty) {
21 if (COMMON_ANODE) duty = PWM_MAX - duty; // ortak anotta mantık ters / logic is inverted for common anode
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23 ledcWrite(PINS[i], duty);
24#else
25 ledcWrite(i, duty);
26#endif
27}
28
29void setRaw(int r, int g, int b) { // gamasız ham değer / raw duty, no gamma
30 pwmWrite(0, r);
31 pwmWrite(1, g);
32 pwmWrite(2, b);
33}
34
35void setup() {
36 pwmSetup();
37}
38
39void loop() {
40 setRaw(PWM_MAX, 0, 0); delay(1000); // kırmızı / red
41 setRaw(0, PWM_MAX, 0); delay(1000); // yeşil / green
42 setRaw(0, 0, PWM_MAX); delay(1000); // mavi / blue
43 setRaw(PWM_MAX, PWM_MAX, PWM_MAX); delay(1000); // beyaz / white
44 setRaw(0, 0, 0); delay(1000); // kapalı / off
45}Convertir un code couleur HEX en RGB
Sur le web, les couleurs s'écrivent au format #RRGGBB : les deux premiers chiffres donnent le rouge, les deux suivants le vert et les deux derniers le bleu, chacun de 0 à 255 et écrit en base seize (hexadécimal). Dans #FF8800, FF = 255, 88 = 8 × 16 + 8 = 136 et 00 = 0 : rouge au maximum, un peu de vert et pas de bleu, donc de l'orange. Le code procède en deux temps : strtol(hex, NULL, 16) transforme le texte de six chiffres en un seul nombre (0xFF8800), puis un décalage de bits et un masque séparent les trois octets : (rgb >> 16) & 0xFF pour le rouge, (rgb >> 8) & 0xFF pour le vert et rgb & 0xFF pour le bleu.
| HEX | Rouge | Vert | Bleu | Couleur |
|---|---|---|---|---|
| #FF0000 | 255 | 0 | 0 | Rouge |
| #00FF00 | 0 | 255 | 0 | Vert |
| #0000FF | 0 | 0 | 255 | Bleu |
| #FF8800 | 255 | 136 | 0 | Orange |
| #800080 | 128 | 0 | 128 | Violet |
| #FFFFFF | 255 | 255 | 255 | Blanc |
| #000000 | 0 | 0 | 0 | Éteint |
Correction gamma : pourquoi les couleurs paraissent délavées ?
L'œil ne perçoit pas la luminosité de façon linéaire : dans le noir, il repère très bien les petites variations, alors qu'en pleine lumière il distingue mal même les grands écarts. C'est pourquoi un rapport cyclique de 50 % paraît déjà presque à pleine puissance, et les tons pastel choisis à l'écran deviennent des couleurs délavées, presque blanches, sur la LED. La solution consiste à appliquer une correction gamma à chaque canal : sortie = maximum × (entrée / 255)^2,2. Les écrans utilisant la même courbe, la couleur du téléphone et celle de la LED se ressemblent beaucoup plus après correction. Le tableau montre à quel point la courbe comprime les tons sombres et pourquoi 10 bits aident :
| Valeur choisie (0–255) | PWM 8 bits (0–255) | PWM 10 bits (0–1023) |
|---|---|---|
| 16 | 1 | 2 |
| 32 | 3 | 11 |
| 64 | 12 | 49 |
| 128 | 56 | 225 |
| 192 | 137 | 548 |
| 255 | 255 | 1023 |
Code principal : serveur web avec sélecteur de couleur pour le téléphone
Le code principal utilise la bibliothèque WebServer fournie avec le core ESP32 : rien d'autre à installer. Indique le nom et le mot de passe de ton réseau, téléverse le code et ouvre le Moniteur série à 115200 bauds. Au bout de quelques secondes s'affiche une adresse comme http://192.168.1.45 ; ouvre-la dans le navigateur d'un téléphone connecté au même réseau WiFi. L'ESP32 ne se connecte qu'aux réseaux 2,4 GHz, et le téléphone doit être sur ce même réseau.
1// ESP32 RGB LED: telefondaki renk seçiciden Wi-Fi ile renk ayarı
2// ESP32 RGB LED: set the colour over Wi-Fi from a colour picker on your phone
3#include <WiFi.h>
4#include <WebServer.h>
5#include <math.h>
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9
10const int PINS[3] = {25, 26, 27}; // R, G, B pinleri / R, G, B pins
11const bool COMMON_ANODE = false; // ortak anot ise true / true for common anode
12const int PWM_FREQ = 5000; // 5 kHz, titreme yok / 5 kHz, no flicker
13const int PWM_BITS = 10; // 0-1023, koyu tonlar daha yumuşak / smoother dark tones
14const int PWM_MAX = (1 << PWM_BITS) - 1;
15const float GAMMA = 2.2; // algısal parlaklık düzeltmesi / perceptual correction
16
17WebServer server(80);
18String currentHex = "000000"; // son seçilen renk / last chosen colour
19
20// Telefonda açılan sayfa / the page opened on the phone
21const char PAGE[] PROGMEM = R"rawliteral(
22<!DOCTYPE html><html><head><meta charset="utf-8">
23<meta name="viewport" content="width=device-width,initial-scale=1">
24<title>ESP32 RGB</title>
25<style>
26body{font-family:sans-serif;text-align:center;background:#111;color:#eee;margin-top:40px}
27input[type=color]{width:200px;height:200px;border:none;background:none}
28button{font-size:18px;padding:10px 20px;margin:6px}
29</style></head><body>
30<h2>ESP32 RGB LED</h2>
31<input type="color" id="c" value="#%HEX%">
32<p id="t">#%HEX%</p>
33<button onclick="pick('#000000')">Kapat / Off</button>
34<button onclick="pick('#ffffff')">Beyaz / White</button>
35<button onclick="pick('#ff8800')">Turuncu / Orange</button>
36<script>
37let busy = false, next = null;
38function send(h) {
39 if (busy) { next = h; return; }
40 busy = true;
41 fetch('/set?hex=' + h.substring(1)).finally(() => {
42 busy = false;
43 if (next) { const n = next; next = null; send(n); }
44 });
45}
46function show(h) { document.getElementById('t').textContent = h; send(h); }
47function pick(h) { document.getElementById('c').value = h; show(h); }
48document.getElementById('c').addEventListener('input', e => show(e.target.value));
49</script></body></html>
50)rawliteral";
51
52void pwmSetup() {
53 for (int i = 0; i < 3; i++) {
54#if ESP_ARDUINO_VERSION_MAJOR >= 3
55 ledcAttach(PINS[i], PWM_FREQ, PWM_BITS); // çekirdek 3.x: pin tabanlı / core 3.x: pin based
56#else
57 ledcSetup(i, PWM_FREQ, PWM_BITS); // çekirdek 2.x: kanal i / core 2.x: channel i
58 ledcAttachPin(PINS[i], i);
59#endif
60 }
61}
62
63void pwmWrite(int i, int duty) {
64 if (COMMON_ANODE) duty = PWM_MAX - duty; // ortak anotta mantık ters / logic is inverted for common anode
65#if ESP_ARDUINO_VERSION_MAJOR >= 3
66 ledcWrite(PINS[i], duty);
67#else
68 ledcWrite(i, duty);
69#endif
70}
71
72int gammaCorrect(int v) { // 0-255 -> 0-PWM_MAX
73 return (int)(pow(v / 255.0, GAMMA) * PWM_MAX + 0.5);
74}
75
76void setColor(int r, int g, int b) {
77 pwmWrite(0, gammaCorrect(r));
78 pwmWrite(1, gammaCorrect(g));
79 pwmWrite(2, gammaCorrect(b));
80}
81
82bool isHex6(const String& s) { // tam 6 onaltılık hane mi? / exactly 6 hex digits?
83 if (s.length() != 6) return false;
84 for (int i = 0; i < 6; i++) {
85 if (!isxdigit((unsigned char)s[i])) return false;
86 }
87 return true;
88}
89
90void handleRoot() {
91 String page(PAGE);
92 page.replace("%HEX%", currentHex); // sayfa son renkle açılsın / open with the last colour
93 server.send(200, "text/html", page);
94}
95
96void handleSet() {
97 String hex = server.arg("hex"); // örnek / example: ff8800
98 if (!isHex6(hex)) {
99 server.send(400, "text/plain", "hex?");
100 return;
101 }
102 long rgb = strtol(hex.c_str(), NULL, 16); // "ff8800" -> 0xFF8800
103 int r = (rgb >> 16) & 0xFF; // 255
104 int g = (rgb >> 8) & 0xFF; // 136
105 int b = rgb & 0xFF; // 0
106 setColor(r, g, b);
107 currentHex = hex;
108 server.send(200, "text/plain", "OK");
109}
110
111void setup() {
112 Serial.begin(115200);
113 pwmSetup();
114 setColor(0, 0, 0);
115 WiFi.mode(WIFI_STA);
116 WiFi.begin(WIFI_SSID, WIFI_PASS);
117 while (WiFi.status() != WL_CONNECTED) {
118 delay(500);
119 Serial.print(".");
120 }
121 WiFi.setSleep(false); // daha hızlı yanıt / faster response
122 Serial.println();
123 Serial.print("Telefonda aç / open on your phone: http://");
124 Serial.println(WiFi.localIP());
125 server.on("/", handleRoot);
126 server.on("/set", handleSet);
127 server.begin();
128}
129
130void loop() {
131 server.handleClient();
132}Comment fonctionne le code ?
| Élément | Rôle |
|---|---|
| PAGE | Le HTML, le CSS et le JavaScript envoyés au téléphone ; R"rawliteral(...)" permet de l'écrire sans échapper les guillemets |
| input type="color" | Ouvre le sélecteur de couleur intégré du téléphone et renvoie le choix sous forme #rrggbb |
| send() et busy | N'envoie qu'une requête à la fois ; parmi les couleurs accumulées pendant le glissement, seule la dernière part |
| /set?hex=ff8800 | La requête qui arrive à l'ESP32 ; handleSet() y répond |
| isHex6() | Vérifie que le texte compte exactement six chiffres hexadécimaux et rejette les requêtes mal formées |
| strtol et décalage de bits | Transforment le texte en nombre et séparent les octets du rouge, du vert et du bleu |
| gammaCorrect() | Ramène la valeur 0–255 sur 0–1023 en suivant la courbe gamma 2,2 |
| pwmWrite() | Inverse la valeur en anode commune et appelle ledcWrite selon la version du core |
| %HEX% | Affiche la dernière couleur à chaque ouverture de la page ; un deuxième téléphone voit ainsi la couleur actuelle |
| WiFi.setSleep(false) | Désactive l'économie d'énergie du WiFi pour que les changements de couleur arrivent sans délai |
La même interface avec un ruban WS2812B
Si tu veux piloter un ruban de dizaines de LED plutôt qu'une seule LED RGB, tu ne touches ni au HTML ni au serveur web : tu remplaces seulement les fonctions qui commandent la LED. Chaque LED WS2812B possède sa propre puce de commande, une seule broche de données suffit donc. Relie l'entrée DIN du ruban à GPIO 13 à travers une résistance de 330 Ω, alimente le ruban avec une alimentation 5 V séparée et relie son GND à celui de l'ESP32. Chaque LED consomme environ 60 mA en blanc maximal ; un ruban de 30 LED peut atteindre 1,8 A, c'est pourquoi le code limite la luminosité à 80/255. Un condensateur de 1000 µF aux bornes d'alimentation protège les LED de l'appel de courant à la mise sous tension. Avec un ruban alimenté en 5 V, le signal de données de 3,3 V de l'ESP32 suffit généralement ; si tu vois du scintillement ou des couleurs aléatoires, ajoute un adaptateur de niveau comme le 74AHCT125. Les détails sur les rubans sont dans le guide ruban LED WS2812B NeoPixel. Place le fragment ci-dessous à la place des quatre fonctions LED du code principal et installe la bibliothèque Adafruit NeoPixel depuis le gestionnaire de bibliothèques :
1// WS2812B şerit: ana koddaki pwmSetup, pwmWrite, gammaCorrect ve setColor yerine bunu koy
2// WS2812B strip: use this instead of pwmSetup, pwmWrite, gammaCorrect and setColor in the main sketch
3#include <Adafruit_NeoPixel.h>
4
5const int STRIP_PIN = 13; // DIN, 330 Ω direnç üzerinden / through a 330 Ω resistor
6const int NUM_LEDS = 30; // şeritteki LED sayısı / number of LEDs on the strip
7Adafruit_NeoPixel strip(NUM_LEDS, STRIP_PIN, NEO_GRB + NEO_KHZ800);
8
9void pwmSetup() { // adı aynı, setup() değişmez / same name, setup() stays as is
10 strip.begin();
11 strip.setBrightness(80); // akımı sınırla / limit the current
12}
13
14void setColor(int r, int g, int b) {
15 strip.fill(strip.gamma32(strip.Color(r, g, b))); // kütüphanenin gama tablosu / the library's gamma table
16 strip.show();
17}
La même conversion en MicroPython (ESP32 et Pico)
Si tu programmes ton ESP32 ou ton Raspberry Pi Pico en MicroPython, le chemin du HEX au PWM est le même ; seule différence, le rapport cyclique s'écrit sur 16 bits (0–65535). Tu peux ajouter la fonction ci-dessous à ton propre serveur web ou à ton code MQTT. Sur la Pico, tu peux par exemple utiliser GP11, GP12 et GP13 pour le rouge, le vert et le bleu.
1# MicroPython (ESP32 ya da Pico): HEX rengi üç PWM kanalına yazar
2# MicroPython (ESP32 or Pico): writes a HEX colour to three PWM channels
3from machine import Pin, PWM
4
5PINS = (25, 26, 27) # Pico'da örneğin (11, 12, 13) / on a Pico e.g. (11, 12, 13)
6GAMMA = 2.2
7leds = []
8for p in PINS:
9 pwm = PWM(Pin(p))
10 pwm.freq(5000)
11 leds.append(pwm)
12
13def set_hex(color):
14 color = color.lstrip("#")
15 rgb = (int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16))
16 for led, v in zip(leds, rgb):
17 led.duty_u16(int(((v / 255) ** GAMMA) * 65535)) # 16 bit görev oranı / 16-bit duty
18
19set_hex("#ff8800") # turuncu / orangeIdées de projets avec une LED RGB et l'ESP32
- Lampe d'ambiance : place la LED RGB dans un bocal en verre dépoli et passe-la en orange chaud depuis ton téléphone le soir.
- Voyant de notification : fais passer la LED au bleu à l'arrivée d'un e-mail ou d'un message ; pour la messagerie, vois le guide bot Telegram avec l'ESP32.
- Éclairage de la pièce : applique la même interface à un ruban RGB 12 V classique avec des MOSFET ; les détails sont dans le guide commande d'un ruban LED RGB.
- Tout le monde voit la même couleur : utilise WebSocket au lieu de HTTP pour que la couleur choisie sur un téléphone s'affiche aussitôt sur les autres pages ouvertes ; le guide ESP32 et WebSocket explique comment.
- Réveil lumineux : récupère l'heure par NTP et, une demi-heure avant le réveil, passe lentement du rouge foncé au blanc ; pour l'horloge, vois le guide horloge NTP avec l'ESP32.
- Domotique : commande la couleur depuis Home Assistant via MQTT ; les étapes sont dans le guide ESP32, MQTT et Home Assistant.
Erreurs fréquentes et solutions
| Symptôme | Cause | Solution |
|---|---|---|
| Tu choisis le rouge et c'est le vert qui s'allume | Les pattes sont sur d'autres broches | Change l'ordre du tableau PINS selon ta LED |
| Avec le noir la LED brille au maximum, avec le blanc elle s'éteint | La LED est à anode commune | Mets COMMON_ANODE = true et relie la patte commune au 3V3 |
| Bleu et vert très faibles, le blanc tire sur le rose | Résistance trop forte pour 3,3 V | Utilise 100 Ω ou 68 Ω pour le vert et le bleu |
| 'ledcSetup' was not declared in this scope | Ancien code avec le core ESP32 3.x | Utilise le test #if ESP_ARDUINO_VERSION_MAJOR de ce guide |
| La page ne s'ouvre pas | Le téléphone est sur un autre réseau, le réseau invité ou les données mobiles | Connecte le téléphone au même réseau 2,4 GHz que l'ESP32 et relis l'IP dans le Moniteur série |
| Le changement de couleur saccade | Économie d'énergie du WiFi ou trop de requêtes | WiFi.setSleep(false) et le drapeau busy ; si le signal est faible, rapproche l'ESP32 de la box |
Choisir la couleur depuis son téléphone est un premier projet WiFi aussi formateur que joli à voir : un seul montage te montre un serveur web, des requêtes HTTP, le PWM et la correction gamma. Dans l'application BlueGrays, les projets Contrôle de LED RGB avec l'ESP32 et Lampe mélangeuse de couleurs ESP32 à trois potentiomètres te guident pas à pas dans ce montage avec schéma de câblage et code prêt à l'emploi, pour que tu puisses ensuite transposer l'idée à ta propre lampe.
Questions fréquentes
Comment commander une LED RGB avec un ESP32 ?
Relie les pattes rouge, verte et bleue de la LED à trois broches GPIO à travers des résistances, et la patte commune au GND (au 3V3 pour une anode commune). Associe un canal PWM à chaque broche avec LEDC et règle la luminosité de chaque couleur en changeant le rapport cyclique. Le mélange des trois donne la teinte voulue.
Pourquoi ledcSetup ne fonctionne plus avec le core ESP32 3.0 ?
Les fonctions LEDC ont changé dans la version 3.0 du core Arduino ESP32 : ledcSetup et ledcAttachPin ont disparu, remplacées par ledcAttach(broche, fréquence, résolution), et ledcWrite prend désormais la broche au lieu du canal. Avec un test #if ESP_ARDUINO_VERSION_MAJOR >= 3, le même code compile sur les deux versions.
Comment savoir si ma LED RGB est à anode commune ou à cathode commune ?
Relie la patte la plus longue au GND et une autre patte au 3,3 V à travers une résistance ; si elle s'allume, c'est une cathode commune. Sinon, inverse le branchement ; si elle s'allume maintenant, c'est une anode commune. En anode commune, la logique du code est inversée : une couleur s'allume quand sa broche est à LOW.
Quelle résistance pour une LED RGB sur un ESP32 ?
En 3,3 V, 150 Ω pour le rouge et 100 Ω pour le vert et le bleu sont un bon point de départ. Avec 220 Ω sur les trois pattes, la LED fonctionne, mais le vert et le bleu restent faibles. Ne tire pas plus de 20 mA en continu sur une broche.
Comment convertir une couleur HEX en RGB ?
Dans le format #RRGGBB, chaque paire de chiffres est la valeur hexadécimale d'une couleur. Dans #FF8800, FF = 255 de rouge, 88 = 136 de vert et 00 = 0 de bleu. Dans un croquis Arduino, strtol(hex, NULL, 16) transforme le texte en nombre, puis un décalage de 16 et 8 bits vers la droite sépare les canaux.
Peut-on piloter un ruban WS2812B depuis le téléphone avec un ESP32 ?
Oui. La page web et le code du serveur restent identiques ; seule la fonction qui écrit la couleur utilise à la place fill et show de la bibliothèque Adafruit NeoPixel. Alimente le ruban avec une alimentation 5 V séparée et relie les masses.
Projets à réaliser après cet article
Voir tous les projets
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.

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

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.

Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
Les LED adressables WS2812B (NeoPixel) sont des LED RGB intelligentes chaînées et pilotées par une seule broche de données. On pilote un ruban WS2812B de 8 LED avec la bibliothèque Adafruit_NeoPixel pour créer un arc-en-ciel fluide. La logique 3,3 V de l'ESP32 convient à la plupart des WS2812B ; en cas d'instabilité, on montre la solution : résistance série de 470Ω et condensateur de 1000µF. L'animation fait glisser la teinte dans l'espace HSV.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Compteur ESP32 WebSocket (2 boutons + écran LCD + affichage Web en temps réel)
Dans ce projet, deux boutons reliés à l'ESP32 (GPIO 5 incrémente, GPIO 4 décrémente) modifient un compteur. La valeur se met à jour instantanément sur un écran LCD I2C 16x2 et, grâce au support WebSocket d'ESPAsyncWebServer, dans tous les navigateurs connectés sans recharger la page. Au lieu du polling HTTP, une seule connexion persistante est utilisée et l'ESP32 envoie la nouvelle valeur à tous avec ws.textAll().

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.
Autres articles
- Utiliser une LED RGB : mélanger les couleurs avec Arduino, anode ou cathode commune
- Serveur web ESP32 asynchrone et WebSocket : pilotage en direct
- Ruban LED WS2812B NeoPixel avec Arduino : guide des LED RGB adressables
- Qu'est-ce que le PWM ? Guide d'analogWrite, du rapport cyclique et de la fréquence sur Arduino
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

