Guides · 10 min de lecture

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.

LED RGB à quatre pattes
Une LED RGB : un seul boîtier contient trois LED, rouge, verte et bleue ; la patte la plus longue est la commune.

Comment ça marche ? Du sélecteur de couleur à la LED

  1. 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.
  2. 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.
  3. 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.
  4. L'ESP32 découpe les six chiffres en trois nombres, 255, 136 et 0, et applique la correction gamma à chacun.
  5. 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.

PatteCathode commune (CC)Anode commune (CA)Résistance
Rouge (R)GPIO 25GPIO 25150 Ω
Patte commune (la plus longue)GND3V3Aucune
Vert (G)GPIO 26GPIO 26100 Ω
Bleu (B)GPIO 27GPIO 27100 Ω
Réglage dans le codeCOMMON_ANODE = falseCOMMON_ANODE = trueAucune
Rapport cyclique pour une couleur au maximum1023 (le maximum)0 (le code l'inverse tout seul)Aucune
Relie la patte commune d'une LED à anode commune à la broche 3V3 de l'ESP32, pas au 5V. En 5 V, il reste environ 1,7 V aux bornes de la LED même quand la broche est à HIGH : le rouge reste faiblement allumé et le courant revient par les diodes de protection vers la broche 3,3 V, qui finit par s'abîmer.

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 coreConfigurationÉ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.

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

HEXRougeVertBleuCouleur
#FF000025500Rouge
#00FF0002550Vert
#0000FF00255Bleu
#FF88002551360Orange
#8000801280128Violet
#FFFFFF255255255Blanc
#000000000É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)
1612
32311
641249
12856225
192137548
2552551023

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.

C++ (Arduino IDE)
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émentRôle
PAGELe 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 busyN'envoie qu'une requête à la fois ; parmi les couleurs accumulées pendant le glissement, seule la dernière part
/set?hex=ff8800La 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 bitsTransforment 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
Pendant que tu fais glisser ton doigt sur le sélecteur, le navigateur déclenche des dizaines d'événements input par seconde. Les envoyer tous en même temps engorge le petit serveur web de l'ESP32 et les couleurs arrivent en retard. Le drapeau busy du code n'envoie pas de nouvelle requête tant que la précédente n'est pas terminée et, parmi les valeurs accumulées, n'envoie que la dernière ; la LED suit ainsi ton doigt sans latence. Ajoute la page à l'écran d'accueil de ton téléphone et elle s'ouvrira d'un geste, comme une application.

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 :

C++ (Arduino IDE)
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}
LED RGB adressable WS2812B
WS2812B : chaque LED embarque sa propre puce de commande ; une seule ligne de données règle la couleur de centaines de LED une par une.

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.

MicroPython
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 / orange

Idé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ômeCauseSolution
Tu choisis le rouge et c'est le vert qui s'allumeLes pattes sont sur d'autres brochesChange l'ordre du tableau PINS selon ta LED
Avec le noir la LED brille au maximum, avec le blanc elle s'éteintLa LED est à anode communeMets COMMON_ANODE = true et relie la patte commune au 3V3
Bleu et vert très faibles, le blanc tire sur le roseRésistance trop forte pour 3,3 VUtilise 100 Ω ou 68 Ω pour le vert et le bleu
'ledcSetup' was not declared in this scopeAncien code avec le core ESP32 3.xUtilise le test #if ESP_ARDUINO_VERSION_MAJOR de ce guide
La page ne s'ouvre pasLe téléphone est sur un autre réseau, le réseau invité ou les données mobilesConnecte 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êtesWiFi.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.

Voir tous les projets
Clignotement LED avec ESP32
ES-1Débutant

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.

4.7(37)
108
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
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
Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
ES-24Intermédiaire
Premium

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.

4.9(19)
30
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

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

4.8(16)
26
Compteur ESP32 WebSocket (2 boutons + écran LCD + affichage Web en temps réel)
ES-28Avancé
Premium

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

4.5(14)
23
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