ESP32 S3 - Capteur de Couleur TCS3200D/TCS230
Apprenez à connecter le capteur de couleur TCS3200D/TCS230 à votre ESP32 S3 pour une détection de couleur RGB précise. Ce tutoriel pour débutants couvre le câblage, l'étalonnage, et les mesures de couleur en temps réel avec votre ESP32 S3.
Ce que vous allez construire :
- Une connexion câblée entre le capteur de couleur TCS3200D/TCS230 et l'ESP32 S3
- Un croquis d'étalonnage qui suit les largeurs d'impulsion minimales et maximales pour chaque canal de couleur
- Un croquis de lecture de couleur qui convertit les données brutes du capteur en valeurs RGB standard (0–255)
- Une sortie sur le Serial Monitor montrant des mesures de couleur en temps réel pour des objets rouges, verts, et bleus
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 S3 (ESP32 S3 inclus) | |
| 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 est un capteur optique qui détecte les couleurs en mesurant les réflexions de lumière à travers des filtres de photodiode spécialisés. Il délivre un signal d'onde carrée dont la fréquence est proportionnelle à l'intensité lumineuse détectée, ce qui rend simple son interfaçage avec les broches d'entrée numérique de l'ESP32 S3. Ses LED blanches intégrées fournissent un éclairage constant, donc les lectures restent fiables dans une variété de conditions de lumière ambiante.
Spécifications Clés
- 64 photodiodes en réseau 8×8 (16 filtres rouges, 16 verts, 16 bleus, 16 transparents)
- Sortie de fréquence proportionnelle à l'intensité lumineuse
- Tension de fonctionnement : 2,7V à 5,5V (5V recommandé)
- Éclairage LED blanc intégré pour des lectures constantes
- Plage de fréquence de sortie : 2 Hz à 500 kHz
- Idéal pour les débutants : sortie numérique simple, pas de lecture analogique complexe
Brochage
Le capteur de couleur TCS3200D/TCS230 a 8 broches de connexion, chacune ayant un rôle spécifique dans l'alimentation, le contrôle, et la sortie de signal :
- VCC : Entrée d'alimentation (connectez à 5V)
- GND : Connexion de masse (référence 0V)
- S0 : Broche de contrôle de mise à l'échelle de fréquence 1
- S1 : Broche de contrôle de mise à l'échelle de fréquence 2
- S2 : Broche de sélection de filtre de couleur 1
- S3 : Broche de sélection de filtre de couleur 2
- OUT : Broche de signal de sortie de fréquence (connectez à une broche numérique de l'ESP32 S3)
- OE : Broche d'activation de sortie (active à LOW, généralement connectée à GND)
Comment Ça Fonctionne
Le capteur de couleur TCS3200 fonctionne en utilisant deux systèmes de contrôle :
Mise à l'échelle de fréquence (broches S0 et S1) :
- S0=LOW, S1=LOW : Mode arrêt
- S0=LOW, S1=HIGH : Mise à l'échelle de fréquence à 2%
- S0=HIGH, S1=LOW : Mise à l'échelle de fréquence à 20%
- S0=HIGH, S1=HIGH : Mise à l'échelle de fréquence à 100% (recommandé)
Sélection de filtre de couleur (broches S2 et S3) :
- S2=LOW, S3=LOW : Filtre rouge actif
- S2=LOW, S3=HIGH : Filtre bleu actif
- S2=HIGH, S3=LOW : Filtre transparent (pas de filtrage)
- S2=HIGH, S3=HIGH : Filtre vert actif
Comment fonctionnent les lectures :
- La broche OUT délivre un signal d'onde carrée
- La fréquence augmente avec une lumière plus vive (2 Hz à 500 kHz)
- L'ESP32 S3 mesure la largeur d'impulsion en utilisant pulseIn()
- Des impulsions plus courtes = lumière plus vive = intensité de couleur plus élevée
- L'étalonnage convertit les largeurs d'impulsion en valeurs RGB standard (0-255)
Maximiser la Précision de Mesure
Suivez ces conseils pour des lectures de couleur TCS3200 précises :
- Gardez la distance du capteur fixe à 1-3 cm de l'objet
- Positionnez le capteur à un angle constant (perpendiculaire fonctionne le mieux)
- Utilisez les LED blanches intégrées pour un éclairage stable
- Protégez le capteur des sources de lumière externes quand possible
- Effectuez l'étalonnage dans votre environnement de travail réel
- Testez sur des surfaces plates et mates pour de meilleurs résultats
Schéma de Câblage
Connectez le capteur de couleur TCS3200D à votre ESP32 S3 en utilisant les affectations de broches dans le tableau ci-dessous. Le capteur fonctionne en 5V, que l'ESP32 S3 fournit via sa broche 5V quand alimenté par USB, donc aucune régulation d'alimentation supplémentaire n'est requise.
Notes de Sécurité
Le capteur TCS3200 fonctionne mieux avec une alimentation 5V, que l'ESP32 S3 peut fournir via la broche 5V quand alimenté par USB. Les lignes de signal du capteur se connectent directement aux broches numériques de l'ESP32 S3 sans décalage de niveau nécessaire pour la plupart des modules, mais vérifiez la tension de sortie de votre module spécifique avant de connecter.
| Capteur de Couleur TCS3200 | ESP32 S3 |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | GPIO41 |
| S1 | GPIO40 |
| S2 | GPIO16 |
| S3 | GPIO7 |
| OUT | GPIO18 |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Code ESP32 S3 - Étalonnage du Capteur
Le code suivant configure le capteur TCS3200 sur votre ESP32 S3 et vous guide à travers un processus d'étalonnage qui capture la plage dynamique complète de votre capteur et environnement spécifiques. Téléversez ce croquis en premier, puis exposez le capteur à une variété de couleurs — du blanc vif au noir profond — afin qu'il puisse enregistrer des valeurs précises de largeur d'impulsion minimale et maximale pour chaque canal.
Ce que fait ce code :
- Alimente le capteur avec une mise à l'échelle de fréquence complète (100%)
- Parcourt les filtres rouge, vert, et bleu
- Suit les largeurs d'impulsion minimales et maximales pour chaque couleur
- Met à jour en continu les valeurs d'étalonnage pendant que vous montrez différentes couleurs
- Affiche des mesures en temps réel dans le Serial Monitor
/*
* Ce code ESP32 S3 a été développé par newbiely.fr
* Ce code ESP32 S3 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/esp32-s3/esp32-s3-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 41 // The ESP32 S3 pin connected to the S0 of the color module
#define PIN_S1 40 // The ESP32 S3 pin connected to the S1 of the color module
#define PIN_S2 16 // The ESP32 S3 pin connected to the S2 of the color module
#define PIN_S3 7 // The ESP32 S3 pin connected to the S3 of the color module
#define PIN_sensorOut 18 // The ESP32 S3 pin connected to the OUT of the color module
// Variables for Color Pulse Width Measurements
int redPW = 0;
int greenPW = 0;
int bluePW = 0;
// Variables to track min and max pulse widths for calibration
int redMin = 10000, redMax = 0;
int greenMin = 10000, greenMax = 0;
int blueMin = 10000, blueMax = 0;
void setup() {
// Set S0 - S3 as outputs
pinMode(PIN_S0, OUTPUT);
pinMode(PIN_S1, OUTPUT);
pinMode(PIN_S2, OUTPUT);
pinMode(PIN_S3, OUTPUT);
// Set Pulse Width scaling to 20%
digitalWrite(PIN_S0, HIGH);
digitalWrite(PIN_S1, LOW);
// Set Sensor output as input
pinMode(PIN_sensorOut, INPUT);
// Setup Serial Monitor
Serial.begin(115200);
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 next code.");
Serial.println("------------------------------------------");
}
void loop() {
// Read Red Pulse Width
redPW = getRedPW();
// Delay to stabilize sensor
delay(200);
// Read Green Pulse Width
greenPW = getGreenPW();
// Delay to stabilize sensor
delay(200);
// Read Blue Pulse Width
bluePW = getBluePW();
// Delay to stabilize sensor
delay(200);
// Update min and max values
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;
// Print the pulse width values with min/max
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("------------------------------------------");
delay(1000);
}
// Function to read Red Pulse Widths
int getRedPW() {
// Set sensor to read Red only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, LOW);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Green Pulse Widths
int getGreenPW() {
// Set sensor to read Green only
digitalWrite(PIN_S2, HIGH);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Blue Pulse Widths
int getBluePW() {
// Set sensor to read Blue only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
Étapes Rapides
- Nouveau sur ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Câblez les composants : Suivez le schéma de câblage ci-dessus pour connecter correctement toutes les broches.
- Connectez votre carte : Branchez l'ESP32 S3 dans votre ordinateur en utilisant un câble USB-C.
- Ouvrez l'Arduino IDE : Lancez le logiciel sur votre ordinateur.
- Sélectionnez votre carte : Choisissez ESP32 S3 et le bon port COM dans le menu Tools.
- Copiez le code : Collez le code d'étalonnage dans un nouveau croquis Arduino IDE.
- Téléversez le code : Cliquez sur le bouton Upload et attendez que le processus se termine.
- Ouvrez le Serial Monitor : Réglez le débit en bauds à 115200 pour voir les données d'étalonnage.
- Pointez vers des objets blancs : Commencez avec du papier blanc vif ou des surfaces blanches.
- Pointez vers des objets noirs : Passez à des surfaces noires sombres.
- Pointez vers des objets colorés : Montrez au capteur divers articles colorés (rouge, vert, bleu, jaune, etc.).
- Regardez les valeurs se stabiliser : Après 10-20 secondes, les nombres Min/Max cesseront de changer de façon significative.
- Enregistrez vos valeurs : Notez les six nombres (redMin, redMax, greenMin, greenMax, blueMin, blueMax).
- Astuce : Gardez la distance du capteur constante (2-3 cm) pendant l'étalonnage pour les résultats les plus précis.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
=== TCS3200 Calibration ===
Point the sensor at different objects (white, black, colors).
Min and Max values are tracked automatically.
When values look stable, note them down for the next code.
------------------------------------------
Red PW = 42 - Green PW = 55 - Blue PW = 60
Min -> R:42 G:55 B:60
Max -> R:42 G:55 B:60
------------------------------------------
Red PW = 210 - Green PW = 185 - Blue PW = 172
Min -> R:42 G:55 B:60
Max -> R:210 G:185 B:172
------------------------------------------
Red PW = 44 - Green PW = 57 - Blue PW = 61
Min -> R:42 G:55 B:60
Max -> R:210 G:185 B:172
------------------------------------------
Red PW = 38 - Green PW = 51 - Blue PW = 58
Min -> R:38 G:51 B:58
Max -> R:210 G:185 B:172
------------------------------------------
Valeurs d'étalonnage de cet exemple :
- RedMin = 38, redMax = 210
- GreenMin = 51, greenMax = 185
- BlueMin = 58, blueMax = 172
Code ESP32 S3 - Lecture de Couleur RGB
Le code suivant applique vos valeurs d'étalonnage enregistrées pour fournir des lectures RGB précises et normalisées depuis le capteur TCS3200. Après avoir inséré vos nombres d'étalonnage, téléversez le croquis et pointez le capteur vers différentes surfaces colorées pour voir la sortie RGB en temps réel dans le Serial Monitor. Les lectures se mettent à jour en continu pendant que vous déplacez des objets colorés dans le champ de vision.
Ce que fait ce code :
- Applique vos valeurs d'étalonnage pour normaliser les lectures du capteur
- Mesure les canaux rouge, vert, et bleu séquentiellement
- Convertit les largeurs d'impulsion brutes au format RGB standard (0-255)
- Affiche les valeurs de couleur en continu dans le Serial Monitor
- Met à jour les lectures en temps réel pendant que vous déplacez des objets colorés
/*
* Ce code ESP32 S3 a été développé par newbiely.fr
* Ce code ESP32 S3 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/esp32-s3/esp32-s3-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 41 // The ESP32 S3 pin connected to the S0 of the color module
#define PIN_S1 40 // The ESP32 S3 pin connected to the S1 of the color module
#define PIN_S2 16 // The ESP32 S3 pin connected to the S2 of the color module
#define PIN_S3 7 // The ESP32 S3 pin connected to the S3 of the color module
#define PIN_sensorOut 18 // The ESP32 S3 pin connected to the OUT of the color module
// Calibration Values
// Replace these values with your actual calibration data from the previous step
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
// Variables for Color Pulse Width Measurements
int redPW = 0;
int greenPW = 0;
int bluePW = 0;
// Variables for final Color values
int redValue;
int greenValue;
int blueValue;
void setup() {
// Set S0 - S3 as outputs
pinMode(PIN_S0, OUTPUT);
pinMode(PIN_S1, OUTPUT);
pinMode(PIN_S2, OUTPUT);
pinMode(PIN_S3, OUTPUT);
// Set Pulse Width scaling to 20%
digitalWrite(PIN_S0, HIGH);
digitalWrite(PIN_S1, LOW);
// Set Sensor output as input
pinMode(PIN_sensorOut, INPUT);
// Setup Serial Monitor
Serial.begin(115200);
}
void loop() {
// Read Red value
redPW = getRedPW();
// Map to value from 0-255
redValue = map(redPW, redMin, redMax, 255, 0);
// Delay to stabilize sensor
delay(200);
// Read Green value
greenPW = getGreenPW();
// Map to value from 0-255
greenValue = map(greenPW, greenMin, greenMax, 255, 0);
// Delay to stabilize sensor
delay(200);
// Read Blue value
bluePW = getBluePW();
// Map to value from 0-255
blueValue = map(bluePW, blueMin, blueMax, 255, 0);
// Delay to stabilize sensor
delay(200);
// Print output to Serial Monitor
Serial.print("Red = ");
Serial.print(redValue);
Serial.print(" - Green = ");
Serial.print(greenValue);
Serial.print(" - Blue = ");
Serial.println(blueValue);
}
// Function to read Red Pulse Widths
int getRedPW() {
// Set sensor to read Red only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, LOW);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Green Pulse Widths
int getGreenPW() {
// Set sensor to read Green only
digitalWrite(PIN_S2, HIGH);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Blue Pulse Widths
int getBluePW() {
// Set sensor to read Blue only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
Étapes Rapides
- Nouveau sur ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Localisez les variables d'étalonnage : Trouvez ces lignes près du haut du code (vers la ligne 10-15) :
int redMin = 0;
int redMax = 0;
int greenMin = 0;
int greenMax = 0;
int blueMin = 0;
int blueMax = 0;
- Insérez vos valeurs d'étalonnage : Remplacez tous les zéros par les nombres que vous avez enregistrés pendant l'étalonnage. Par exemple :
int redMin = 38;
int redMax = 210;
int greenMin = 51;
int greenMax = 185;
int blueMin = 58;
int blueMax = 172;
- Téléversez le code : Cliquez sur Upload pour transférer le code modifié sur votre ESP32 S3.
- Ouvrez le Serial Monitor : Réglez le débit en bauds à 115200 pour voir les valeurs RGB.
- Testez avec des objets colorés : Placez des articles rouges, verts, bleus, jaunes, ou d'autres couleurs devant le capteur.
- Lisez les valeurs RGB : Regardez les mesures de couleur se mettre à jour en temps réel sur le Serial Monitor.
- Astuce : Pour des résultats constants, maintenez toujours la même distance et les mêmes conditions d'éclairage que celles utilisées pendant l'étalonnage.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 10:22:01] Red = 210 - Green = 35 - Blue = 20
[2026-01-15 10:22:02] Red = 215 - Green = 38 - Blue = 22
[2026-01-15 10:22:03] Red = 208 - Green = 33 - Blue = 18
[2026-01-15 10:22:05] Red = 25 - Green = 200 - Blue = 40
[2026-01-15 10:22:06] Red = 28 - Green = 205 - Blue = 42
[2026-01-15 10:22:07] Red = 22 - Green = 198 - Blue = 38
[2026-01-15 10:22:09] Red = 30 - Green = 45 - Blue = 215
[2026-01-15 10:22:10] Red = 33 - Green = 48 - Blue = 220
[2026-01-15 10:22:11] Red = 28 - Green = 42 - Blue = 210
Comprendre la sortie :
- Les valeurs vont de 0 (aucune couleur détectée) à 255 (intensité maximale)
- Des nombres plus élevés signifient que plus de cette couleur est réfléchie
- Les trois premières lignes montrent un objet rouge (valeur rouge élevée, vert/bleu faible)
- Les trois lignes du milieu montrent un objet vert (valeur verte élevée)
- Les trois dernières lignes montrent un objet bleu (valeur bleue élevée)
Applications du Projet
L'ESP32 S3 associé au capteur TCS3200D/TCS230 ouvre la porte à une large gamme de projets sensibles aux couleurs, des simples tâches de détection aux systèmes automatisés complexes.
- Trieur de couleur automatisé : Triez des M&Ms, des briques LEGO, ou des perles par couleur en utilisant un mécanisme à servomoteur
- Jeu d'association de couleurs : Défiez les utilisateurs de trouver des objets correspondant à une valeur RGB cible
- Robot suiveur de ligne : Créez un robot qui suit des chemins de ruban coloré sur le sol
- Système de contrôle qualité : Détectez des produits défectueux en comparant les couleurs à des standards de référence
- Contrôleur d'éclairage intelligent : Ajustez automatiquement les couleurs de LED RGB pour correspondre aux couleurs ambiantes détectées
- Identificateur de couleur de peinture : Construisez un appareil portable qui identifie les couleurs de peinture pour la décoration intérieure
- Mélangeur de couleur éducatif : Démontrez la théorie des couleurs additives en affichant les valeurs RGB de couleurs mélangées
Section Vidéo
Regardez la vidéo étape par étape pour ce projet ESP32 S3 ci-dessous.
Défiez-vous
Ces défis pousseront vos compétences ESP32 S3 et TCS3200 plus loin, des simples retours LED aux applications complètes de diffusion de couleur sans fil.
- Débutant : Ajoutez une LED RGB qui s'allume avec la même couleur que le capteur détecte
- Débutant : Affichez des noms de couleur (« Red », « Green », « Blue ») au lieu de simples nombres quand des couleurs primaires sont détectées
- Intermédiaire : Construisez un jeu de mémoire de couleur qui montre des couleurs aléatoires et teste si les utilisateurs peuvent les faire correspondre
- Intermédiaire : Créez un système de sécurité basé sur la couleur qui ne se déverrouille que quand un objet coloré spécifique est montré
- Avancé : Construisez un trieur de couleur complet avec des servomoteurs qui séparent physiquement les objets en bacs par couleur
- Avancé : Développez une application smartphone qui reçoit les valeurs RGB de l'ESP32 S3 via Bluetooth et affiche la couleur réelle à l'écran