Arduino UNO Q - Capteur de Couleur TCS3200D/TCS230
Le capteur de reconnaissance de couleurs TCS3200D/TCS230 détecte les couleurs en mesurant l'intensité lumineuse rouge, verte et bleue. Il génère un signal basé sur la fréquence que vous lisez avec pulseIn(), puis mappez sur des valeurs RGB standard de 0 à 255 après calibration.
Dans ce tutoriel, vous apprendrez :
- Comment fonctionne le capteur de couleur TCS3200D/TCS230
- Comment le câbler au MCU de l'Arduino UNO Q
- Comment exécuter le sketch de calibration pour obtenir des lectures précises
- Comment lire les valeurs RGB et détecter les couleurs dominantes
- Comment utiliser Bridge pour exposer les données de couleur au côté Linux (Python)
- Comment utiliser Telegram pour interroger les valeurs RGB et le nom de la couleur sur l'Arduino UNO Q
- Comment utiliser OpenClaw sur l'Arduino UNO Q avec le capteur de couleur
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À Propos du Capteur de Couleur TCS3200D/TCS230
Le TCS3200D/TCS230 utilise un tableau 8×8 de photodiodes : 16 filtrées en rouge, 16 filtrées en vert, 16 filtrées en bleu et 16 sans filtre. Il convertit l'intensité lumineuse en une fréquence d'onde carrée sur la broche OUT. En commutant les filtres et en mesurant les largeurs d'impulsion, vous obtenez des valeurs RGB.
La plupart des modules comprennent des LEDs blanches pour illuminer l'objet cible, donnant des lectures cohérentes dans des conditions d'éclairage ambiant variables.
Brochage
- VCC : Alimentation 5V
- GND : Masse
- S0, S1 : Mise à l'échelle de la fréquence de sortie — HIGH/LOW = mise à l'échelle à 20% (recommandé)
- S2, S3 : Sélection du filtre de couleur
- OUT : Sortie de fréquence d'onde carrée — mesurez avec pulseIn()
- OE : Activation de la sortie (actif LOW) — la plupart des modules le câblent en interne à GND
Sélection du Filtre (S2, S3)
| S2 | S3 | Filtre |
|-----|-----|---------|
| LOW | LOW | Rouge |
| LOW | HIGH| Bleu |
| HIGH| LOW | Sans filtre |
| HIGH| HIGH| Vert |
Largeur d'Impulsion → RGB
Largeur d'impulsion plus faible = plus de lumière = valeur RGB plus élevée. Après calibration :
rgb = map(pulseWidth, calibMin, calibMax, 255, 0);
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Broche TCS3200 | MCU Arduino UNO Q |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | D4 |
| S1 | D3 |
| S2 | D6 |
| S3 | D5 |
| OUT | D7 |
Comment Programmer pour le Capteur de Couleur TCS3200
- Configurer toutes les broches de contrôle comme sorties, OUT comme entrée, définir la mise à l'échelle de fréquence :
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
digitalWrite(S0, HIGH); // 20% scaling
digitalWrite(S1, LOW);
- Sélectionner un filtre et mesurer la largeur d'impulsion :
// Red
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
int redPW = pulseIn(sensorOut, LOW);
// Green
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
int greenPW = pulseIn(sensorOut, LOW);
// Blue
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
int bluePW = pulseIn(sensorOut, LOW);
- Mapper sur 0-255 après calibration (PW plus faible = plus lumineux = valeur plus élevée) :
int redValue = map(redPW, redMin, redMax, 255, 0);
Code Arduino UNO Q — Calibration
Les lectures du TCS3200 sont affectées par la distance, la luminosité des LEDs et la lumière ambiante. Exécutez d'abord ce sketch de calibration pour trouver les largeurs d'impulsion minimales et maximales pour votre configuration spécifique.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// TCS3200 Color Sensor - Calibration Sketch
// Run this first to find the min/max pulse widths for your environment.
// Point the sensor at white, black, and various colored objects.
// Note the stable Min and Max values, then enter them into the main sketch.
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
int redPW = 0, greenPW = 0, bluePW = 0;
int redMin = 10000, redMax = 0;
int greenMin = 10000, greenMax = 0;
int blueMin = 10000, blueMax = 0;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Serial.begin(9600);
Serial.println("=== TCS3200 Calibration ===");
Serial.println("Point the sensor at different objects (white, black, colors).");
Serial.println("Min and Max values are tracked automatically.");
Serial.println("When values look stable, note them down for the main sketch.");
Serial.println("------------------------------------------");
}
void loop() {
redPW = getRedPW(); delay(200);
greenPW = getGreenPW(); delay(200);
bluePW = getBluePW(); delay(200);
if (redPW < redMin) redMin = redPW;
if (redPW > redMax) redMax = redPW;
if (greenPW < greenMin) greenMin = greenPW;
if (greenPW > greenMax) greenMax = greenPW;
if (bluePW < blueMin) blueMin = bluePW;
if (bluePW > blueMax) blueMax = bluePW;
Serial.print("Red PW = "); Serial.print(redPW);
Serial.print(" - Green PW = "); Serial.print(greenPW);
Serial.print(" - Blue PW = "); Serial.println(bluePW);
Serial.print(" Min -> R:"); Serial.print(redMin);
Serial.print(" G:"); Serial.print(greenMin);
Serial.print(" B:"); Serial.println(blueMin);
Serial.print(" Max -> R:"); Serial.print(redMax);
Serial.print(" G:"); Serial.print(greenMax);
Serial.print(" B:"); Serial.println(blueMax);
Serial.println("------------------------------------------");
}
Étapes Rapides
Première utilisation d'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q avant de continuer.
- Connecter : Câblez le capteur de couleur à l'Arduino UNO Q MCU comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créer une nouvelle application : Cliquez sur le bouton Créer une nouvelle application.
- Donnez un nom à l'application, par exemple : ColorSensorCalibration
- Cliquez sur Créer pour confirmer.
- Coller le sketch : Copiez le code de calibration ci-dessus et collez-le dans sketch/sketch.ino.
- Téléverser : Cliquez sur le bouton Exécuter dans Arduino App Lab.
- Déplacez le capteur sur différents objets : un objet blanc, un objet noir et quelques objets colorés.
- Regardez les valeurs Min et Max se stabiliser après 10–20 secondes — notez-les.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:00] === TCS3200 Calibration ===
[2026-04-29 09:00:00] Point the sensor at different objects (white, black, colors).
[2026-04-29 09:00:00] Min and Max values are tracked automatically.
[2026-04-29 09:00:00] When values look stable, note them down for the main sketch.
[2026-04-29 09:00:00] ------------------------------------------
[2026-04-29 09:00:01] Red PW = 42 - Green PW = 55 - Blue PW = 60
[2026-04-29 09:00:01] Min -> R:42 G:55 B:60
[2026-04-29 09:00:01] Max -> R:42 G:55 B:60
[2026-04-29 09:00:01] ------------------------------------------
[2026-04-29 09:00:02] Red PW = 210 - Green PW = 185 - Blue PW = 172
[2026-04-29 09:00:02] Min -> R:42 G:55 B:60
[2026-04-29 09:00:02] Max -> R:210 G:185 B:172
[2026-04-29 09:00:02] ------------------------------------------
D'après la sortie ci-dessus, vos valeurs de calibration sont :
- redMin = 42, redMax = 210
- greenMin = 55, greenMax = 185
- blueMin = 60, blueMax = 172
Code Arduino UNO Q — Lire les Valeurs RGB
Maintenant, mettez à jour les six variables de calibration en haut avec vos valeurs réelles et téléversez ce sketch principal pour lire des valeurs RGB précises.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// TCS3200 Color Sensor - Read RGB Values
// IMPORTANT: Run the calibration sketch first and replace the 0 values below
// with your actual calibration numbers.
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
// Calibration values — replace with your values from the calibration sketch
int redMin = 0; // Red minimum pulse width
int redMax = 0; // Red maximum pulse width
int greenMin = 0; // Green minimum pulse width
int greenMax = 0; // Green maximum pulse width
int blueMin = 0; // Blue minimum pulse width
int blueMax = 0; // Blue maximum pulse width
int redPW = 0, greenPW = 0, bluePW = 0;
int redValue = 0, greenValue = 0, blueValue = 0;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Serial.begin(9600);
Serial.println("Arduino UNO Q TCS3200 Color Sensor ready");
}
void loop() {
redPW = getRedPW(); delay(200);
greenPW = getGreenPW(); delay(200);
bluePW = getBluePW(); delay(200);
// Map pulse width to 0-255 (lower PW = more light = higher value)
redValue = map(redPW, redMin, redMax, 255, 0);
greenValue = map(greenPW, greenMin, greenMax, 255, 0);
blueValue = map(bluePW, blueMin, blueMax, 255, 0);
Serial.print("Red = "); Serial.print(redValue);
Serial.print(" - Green = "); Serial.print(greenValue);
Serial.print(" - Blue = "); Serial.println(blueValue);
}
Étapes Rapides
- Dans le code ci-dessus, trouvez ces lignes :
int redMin = 0;
int redMax = 0;
int greenMin = 0;
int greenMax = 0;
int blueMin = 0;
int blueMax = 0;
- Remplacez les six valeurs 0 par vos numéros de calibration. Par exemple :
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
- Créez une nouvelle application (ou mettez à jour la précédente), collez le code, et cliquez sur Exécuter.
- Pointez le capteur sur différents objets colorés et observez la sortie du Moniteur Série.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q TCS3200 Color Sensor ready
[2026-04-29 09:00:02] Red = 210 - Green = 35 - Blue = 20
[2026-04-29 09:00:03] Red = 25 - Green = 200 - Blue = 40
[2026-04-29 09:00:04] Red = 30 - Green = 45 - Blue = 215
[2026-04-29 09:00:05] Red = 225 - Green = 220 - Blue = 218
Bridge : Linux + MCU
Cette section montre comment les deux processeurs de l'Arduino UNO Q fonctionnent ensemble pour que le côté Linux puisse lire en continu les données de couleur via Bridge :
- Le capteur de couleur est connecté au MCU — le MCU lit les valeurs RGB toutes les 600 ms et les met en cache
- Le MPU ne peut pas lire le capteur directement — il appelle les fonctions Bridge pour obtenir les valeurs RGB ou le nom de la couleur
- Le MPU dispose du Wi-Fi — exécutant Debian Linux complet, il peut répondre aux commandes Telegram avec des lectures de couleur en temps réel
- Arduino_RouterBridge permet la communication RPC entre les deux processeurs
- ⚠️ /dev/ttyHS1 (Linux) et Serial1 (MCU) sont RÉSERVÉS par le routeur — ne les ouvrez jamais dans le code utilisateur
La boucle MCU lit les canaux R, G, B toutes les 600 ms et met en cache les valeurs. Les callbacks Bridge servent les valeurs mises en cache instantanément, sans bloquer.
Code MCU (Bridge)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
#include "Arduino_RouterBridge.h"
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
// Calibration values — replace with your values from the calibration sketch
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
// Cached RGB values
int cached_red = 0;
int cached_green = 0;
int cached_blue = 0;
unsigned long last_read_ms = 0;
const unsigned long READ_INTERVAL = 600;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
String get_rgb(String arg) {
return "R:" + String(cached_red) + " G:" + String(cached_green) + " B:" + String(cached_blue);
}
String get_color(String arg) {
int r = cached_red;
int g = cached_green;
int b = cached_blue;
// Detect dominant color
if (r > 200 && g > 200 && b > 200) return "white";
if (r < 50 && g < 50 && b < 50) return "black";
if (r > g && r > b) return "red";
if (g > r && g > b) return "green";
if (b > r && b > g) return "blue";
return "unknown";
}
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Bridge.provide("get_rgb", get_rgb);
Bridge.provide("get_color", get_color);
Monitor.println("Arduino UNO Q TCS3200 Color Sensor Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= READ_INTERVAL) {
last_read_ms = now;
int redPW = getRedPW(); delay(200);
int greenPW = getGreenPW(); delay(200);
int bluePW = getBluePW(); delay(200);
cached_red = constrain(map(redPW, redMin, redMax, 255, 0), 0, 255);
cached_green = constrain(map(greenPW, greenMin, greenMax, 255, 0), 0, 255);
cached_blue = constrain(map(bluePW, blueMin, blueMax, 255, 0), 0, 255);
}
}
Code Python (Bridge)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
from arduino.app_utils import *
import time
def loop():
rgb = Bridge.call("get_rgb")
color = Bridge.call("get_color")
print(f"Color: {color} | {rgb}")
time.sleep(1)
App.run(user_loop=loop)
Étapes Rapides
- Connecter : Câblez le capteur de couleur à l'Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab et créer une nouvelle application nommée ColorSensorBridge.
- Mettre à jour les valeurs de calibration dans le code MCU Bridge (redMin, redMax, etc.) avec vos valeurs du sketch de calibration.
- Coller le sketch MCU dans sketch/sketch.ino.
- Coller le code Python dans le fichier Python.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Téléverser : Cliquez sur le bouton Exécuter.
- Pointez le capteur sur différents objets colorés — regardez la console Python se mettre à jour toutes les secondes.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q TCS3200 Color Sensor Bridge ready
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] Color: red | R:215 G:30 B:25
[2026-04-29 09:00:03] Color: green | R:28 G:205 B:38
[2026-04-29 09:00:04] Color: blue | R:22 G:40 B:218
[2026-04-29 09:00:05] Color: white | R:228 G:222 B:220
[2026-04-29 09:00:06] Color: black | R:12 G:10 B:8
Telegram
Interrogez le capteur de couleur à distance via des commandes Telegram sur l'Arduino UNO Q.
Sketch MCU : Conservez le même sketch MCU de la section Bridge précédente.
Code Python (Telegram)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
from arduino.app_utils import *
import requests
import time
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
CHAT_ID = "YOUR_CHAT_ID"
last_update_id = 0
def get_updates():
global last_update_id
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates"
params = {"offset": last_update_id + 1, "timeout": 5}
try:
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["ok"]:
return data["result"]
except Exception as e:
print(f"Error getting updates: {e}")
return []
def send_message(chat_id, text):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {"chat_id": chat_id, "text": text}
try:
requests.post(url, data=payload, timeout=10)
except Exception as e:
print(f"Error sending message: {e}")
def loop():
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
if "message" not in update:
continue
message = update["message"]
chat_id = message["chat"]["id"]
text = message.get("text", "").strip()
print(f"Received: {text}")
if text == "/start":
send_message(chat_id,
"Arduino UNO Q Color Sensor Bot\n"
"/rgb - Read RGB values (0-255)\n"
"/color - Detect dominant color")
elif text == "/rgb":
result = Bridge.call("get_rgb")
send_message(chat_id, f"RGB values: {result}")
elif text == "/color":
result = Bridge.call("get_color")
send_message(chat_id, f"Detected color: {result}")
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(0.5)
App.run(user_loop=loop)
Étapes Rapides
- Remplacez YOUR_TELEGRAM_BOT_TOKEN par votre vrai token de bot Telegram de BotFather.
- Remplacez YOUR_CHAT_ID par votre identifiant de chat Telegram.
- Collez ce code Python dans le fichier Python de votre application (conservez le même sketch MCU).
- Cliquez sur le bouton Exécuter et testez avec les commandes /rgb et /color.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:00] Waiting for Telegram messages...
[2026-04-29 09:10:03] Received: /rgb
[2026-04-29 09:10:06] Received: /color
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées de Projets
Vous pouvez réaliser de nombreux projets utiles avec le capteur de couleur TCS3200 et l'Arduino UNO Q :
- Machine de Tri par Couleur : Détectez la couleur des objets sur un convoyeur via Bridge — faites en sorte que le MCU déclenche un servo pour rediriger chaque objet vers le bon bac en fonction de sa couleur détectée
- Enregistreur de Couleur à Distance : Enregistrez les couleurs détectées et les valeurs RGB dans un fichier CSV sur Linux toutes les 5 secondes — utilisez une commande Telegram /report pour obtenir les 10 dernières lectures avec horodatages
- Alerte Activée par Couleur : Utilisez Telegram pour définir une couleur cible — quand le capteur détecte exactement cette couleur, envoyez une notification Telegram instantanée (ex. : pour le contrôle qualité sur une ligne de production)
- Moniteur de Santé des Plantes : Pointez le capteur sur des feuilles de plantes — suivez la valeur du canal vert quotidiennement pour détecter un jaunissement ou une décoloration précoce, et envoyez une alerte Telegram si la valeur verte tombe en dessous d'un seuil
- Jeu de Couleur Interactif : Envoyez un message Telegram comme "Montrez-moi BLEU en 10 secondes" — le MCU lit la couleur et Python répond si le joueur a montré la bonne couleur avant le minuteur
Défiez-Vous
Prêt à aller plus loin avec le capteur de couleur TCS3200 sur l'Arduino UNO Q ? Essayez ces défis :
- Facile : Ajoutez une commande Telegram /history qui retourne les 5 dernières couleurs détectées avec horodatages stockées dans une liste Python — utile pour revoir les lectures récentes sans vérifier la console.
- Moyen : Implémentez le moyennage : au lieu de mettre en cache une seule lecture, faites lire au MCU chaque canal R/G/B 3 fois et retourner la moyenne — cela lisse le bruit et améliore la précision de la détection des couleurs.
- Avancé : Construisez un système d'apprentissage des couleurs : ajoutez les commandes Telegram /learn red, /learn green, /learn blue qui capturent la lecture RGB actuelle et la stockent comme référence pour cette couleur — utilisez ensuite ces références stockées pour la correspondance des couleurs au lieu de seuils codés en dur.