Home
ESP32

ESP32 - Capteur de couleur TCS3200D/TCS230

Ce guide vous explique comment connecter un capteur de couleur TCS3200D/TCS230 à l'ESP32 pour une détection et une mesure précises des couleurs RVB. Apprenez à calibrer le capteur et à programmer l'ESP32 pour lire les valeurs de couleur des objets.

Ce que vous apprendrez :

ESP32 avec le module capteur de reconnaissance des couleurs TCS3200D/TCS230 – tutoriel

Préparation du matériel

1×Module de développement ESP32 ESP-WROOM-32
1×Alternativement: ESP32 Uno-form board
1×Alternativement: ESP32 S3 Uno-form board
1×Câble USB Type-A vers Type-C (pour PC USB-A)
1×Câble USB Type-C vers Type-C (pour PC USB-C)
1×TCS3200D/TCS230 Color Recognition Sensor Module
1×Plaque d'essai
1×Fils de connexion
1×Recommandé: Carte d'extension à bornier à vis pour ESP32
1×Recommandé: Breakout Expansion Board for ESP32
1×Recommandé: Répartiteur d'alimentation pour ESP32

Ou vous pouvez acheter les kits suivants:

1×Kit de Démarrage DIYables ESP32 (ESP32 inclus)
1×Kit de Capteurs DIYables (30 capteurs/écrans)
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 une matrice de 64 photodiodes organisée en configuration 8×8 pour l'identification des couleurs. Cet ensemble comprend 16 photodiodes munies de filtres optiques rouges, 16 avec des filtres verts, 16 avec des filtres bleus et 16 sans filtres (clair). Le capteur fonctionne en sélectionnant des types de filtres spécifiques et en convertissant l'intensité lumineuse détectée en une sortie d'onde carrée modulée en fréquence.

La plupart des modules capteurs disposent d’un éclairage LED blanc intégré, ce qui garantit la cohérence des mesures en fournissant une source lumineuse contrôlée, indépendante des conditions ambiantes.

Plan de brochage

Le module capteur TCS3200D/TCS230 fournit ces points de connexion :

  • Broche VCC : Connectez-la à une alimentation de 3,3 V ou 5 V.
  • Broche GND : Connectez-la à la masse (0 V).
  • Broches S0, S1 : Réglages d'échelle de fréquence de sortie.
  • Broches S2, S3 : Sélecteurs de filtre couleur.
  • Broche OUT : Signal de sortie de fréquence en forme d'onde carrée.
  • Broche OE : Activation de la sortie (active à niveau bas). Généralement pré-câblée à la masse sur les modules commerciaux. Si elle est exposée, connectez-la à la masse.
Schéma de brochage du module capteur de couleur TCS3200/TCS230 montrant VCC, GND, S0, S1, S2, S3 et OUT

Comment ça fonctionne

Le fonctionnement du capteur dépend de deux paramètres configurables : le filtre de couleur actif et le niveau du signal de sortie. Deux paires de broches de contrôle déterminent ces réglages :

Les broches S0/S1 configurent l'échelle de fréquence de sortie :

  • S0=LOW, S1=LOW: Capteur hors tension
  • S0=LOW, S1=HIGH: Sortie à 2 % de la fréquence de base
  • S0=HIGH, S1=LOW: Sortie à 20 % de la fréquence de base
  • S0=HIGH, S1=HIGH: Sortie à 100 % de la fréquence de base

Les broches S2 et S3 sélectionnent le filtre de couleur actif :

  • S2=BAS, S3=BAS: filtre rouge activé
  • S2=BAS, S3=HAUT: filtre bleu activé
  • S2=HAUT, S3=BAS: Aucun filtre (clair/sans filtre)
  • S2=HAUT, S3=HAUT: filtre vert activé

La broche OUT produit une sortie de fréquence comprise entre environ 2 Hz et 500 kHz. La fréquence est corrélée à l'intensité lumineuse — plus il y a de lumière, plus la fréquence est élevée. L'utilisation de pulseIn() pour mesurer la durée de l'impulsion donne l'inverse — une largeur d'impulsion plus courte indique un éclairage plus lumineux. Après calibration, ces mesures se convertissent en valeurs RGB standard de 0 à 255.

Optimiser la stabilité des mesures

  • Positionner le capteur à 1 à 3 cm de la surface cible, avec une orientation constante.
  • Activer les LED blanches intégrées pour un éclairage standardisé.
  • Bloquer les sources lumineuses externes pour réduire la variabilité des mesures.

Diagramme de câblage

Schéma de connexion ESP32 vers le capteur de couleur TCS3200 :

TCS3200 Color SensorESP32
VCC3.3V
GNDGND
S0GPIO 17
S1GPIO 16
S2GPIO 18
S3GPIO 5
OUTGPIO 19
Schéma de câblage ESP32 et du capteur de couleur TCS3200 montrant la connexion entre les broches

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Si vous ne savez pas comment alimenter l'ESP32 et d'autres composants, consultez les instructions dans le tutoriel suivant : Comment alimenter l'ESP32..

Code ESP32 - Calibration du capteur par largeur d'impulsion

L'étalonnage compense les variables environnementales qui affectent les mesures brutes du capteur : variations d'intensité lumineuse des LED, distance de l'objet, différences de réflectivité des surfaces et conditions d'éclairage ambiant. Ces facteurs introduisent des erreurs de mesure qui doivent être quantifiées. Le processus d'étalonnage enregistre les largeurs d'impulsion minimales et maximales pour chaque canal de couleur, créant des limites pour une cartographie RGB précise de 0 à 255 dans votre environnement spécifique.

/* * Ce code ESP32 a été développé par newbiely.fr * Ce code ESP32 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/esp32-tcs3200d-tcs230-color-sensor */ // Define color sensor pins #define PIN_S0 17 // The ESP32 pin connected to the S0 of the color module #define PIN_S1 16 // The ESP32 pin connected to the S1 of the color module #define PIN_S2 18 // The ESP32 pin connected to the S2 of the color module #define PIN_S3 5 // The ESP32 pin connected to the S3 of the color module #define PIN_sensorOut 19 // The ESP32 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(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 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

  • Si c'est la première fois que vous utilisez l'ESP32, consultez Installation du logiciel ESP32..
  • Copiez le code d'étalonnage dans l'IDE Arduino
  • Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code sur l'ESP32
  • Ouvrez le Moniteur série (réglez le débit à 9600 bauds)
  • Orientez le capteur vers des objets de couleurs différentes : papier blanc, surface noire et diverses couleurs
  • Surveillez les valeurs min et max qui se mettent à jour automatiquement
  • Après que les valeurs se soient stabilisées (10-20 secondes), notez les six valeurs d'étalonnage
COM6
Send
=== 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 ------------------------------------------
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Exemple de résultats d'étalonnage issus de la sortie :

  • RougeMin = 42, rougeMax = 210
  • VertMin = 55, vertMax = 185
  • BleuMin = 60, bleuMax = 172

Code ESP32 - Lecture des valeurs de couleur RVB

/* * Ce code ESP32 a été développé par newbiely.fr * Ce code ESP32 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/esp32-tcs3200d-tcs230-color-sensor */ // Define color sensor pins #define PIN_S0 17 // The ESP32 pin connected to the S0 of the color module #define PIN_S1 16 // The ESP32 pin connected to the S1 of the color module #define PIN_S2 18 // The ESP32 pin connected to the S2 of the color module #define PIN_S3 5 // The ESP32 pin connected to the S3 of the color module #define PIN_sensorOut 19 // The ESP32 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(9600); } 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

  • Trouvez les constantes d'étalonnage en haut du code :

Aucun contenu fourni à traduire.

int redMin = 0; // Largeur d'impulsion minimale du rouge

int redMax = 0; // Largeur d'impulsion maximale rouge

int greenMin = 0; // Largeur d'impulsion minimale pour le vert

int greenMax = 0; // Largeur d'impulsion maximale du vert

int blueMin = 0; // Largeur d'impulsion minimale bleue

int blueMax = 0; // Largeur d'impulsion maximale bleue

Please provide the English text to translate. The code block is currently empty.

  • Remplacez les six zéros par vos valeurs de calibration réelles. Par exemple (en utilisant redMin = 42, redMax = 210, greenMin = 55, greenMax = 185, blueMin = 60, blueMax = 172) :

Please provide the English text to translate.

int rougeMin = 42;

int rougeMax = 210;

int vertMin = 55;

int maxVert = 185;

int bleuMin = 60;

int bleuMax = 172;

Please provide the English content to translate; it appears the text is missing between the code blocks.

  • Copiez le code ci-dessus et ouvrez-le dans l'IDE Arduino
  • Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code vers l'ESP32
  • Placez un objet de couleur devant le capteur
  • Consultez le résultat dans le Moniteur série
COM6
Send
Red = 210 - Green = 35 - Blue = 20 Red = 25 - Green = 200 - Blue = 40 Red = 30 - Green = 45 - Blue = 215
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

La sortie affiche désormais les valeurs RVB standard de 0 à 255. Des largeurs d'impulsion plus courtes (éclairage plus lumineux) donnent des valeurs RVB plus élevées ; des largeurs d'impulsion plus longues (conditions moins lumineuses) produisent des valeurs RVB plus faibles.

Candidatures au projet

Avec une capacité de lecture RGB fonctionnelle, explorez ces possibilités de projets :

  • Tri automatique des couleurs: Classer les articles par teinte (identification des couleurs rouge, vert et bleu)
  • Système de comparaison des couleurs: Vérifier l'appariement des couleurs entre les objets
  • Suivi de ligne chromatique: Construire des robots qui suivent des chemins colorés
  • Contrôle qualité de fabrication: Identifier les unités défectueuses par écart de couleur
  • Réponse déclenchée par la couleur: Activer des avertisseurs sonores ou des indicateurs lors de la détection de couleurs spécifiques

Vidéo

Références de fonctions

Tutoriels connexes

※ NOS MESSAGES

  • N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !
DIVULGATION
Newbiely.fr participe au Programme Partenaires d'Amazon Services LLC, un programme de publicité d'affiliation conçu pour permettre aux sites de percevoir une rémunération grâce à la création de liens vers Amazon.com, Amazon.it, Amazon.fr, Amazon.co.uk, Amazon.ca, Amazon.de, Amazon.es, Amazon.nl, Amazon.pl et Amazon.se
Copyright © 2026 Newbiely.fr. Tous droits réservés.
Conditions d'utilisation | Politique de confidentialité
Email: newbiely.com@gmail.com