ESP32 C3 Super Mini - Capteur de couleur TCS3200D/TCS230
Apprenez à connecter le capteur de couleur TCS3200D/TCS230 à votre ESP32 C3 Super Mini pour une détection précise des couleurs RVB. Ce tutoriel adapté aux débutants couvre l'étalonnage et les mesures de couleur en temps réel.
Ce que vous apprendrez:
- Ce qu'est le capteur de couleur TCS3200D/TCS230 et comment il détecte les couleurs
- Comment câbler le capteur TCS3200 à ESP32 C3 Super Mini
- Comment étalonner le capteur pour des lectures précises
- Comment lire et afficher les valeurs de couleur RVB
- Les applications réelles des projets de détection de couleur
Matériel requis
| 1 | × | ESP32 C3 Super Mini | |
| 1 | × | Câble USB Type-C | |
| 1 | × | Module capteur de reconnaissance de couleur TCS3200D/TCS230 | |
| 1 | × | Plaque de prototypage | |
| 1 | × | Fils de liaison |
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 est un capteur optique qui détecte les couleurs en mesurant les réflexions de lumière à travers des filtres photodiodes spécialisés.
Caractéristiques principales:
- 64 photodiodes dans un tableau 8×8 (16 filtres rouges, 16 verts, 16 bleus, 16 clairs)
- Sortie de fréquence proportionnelle à l'intensité lumineuse
- Tension de fonctionnement: 2,7V à 5,5V (5V recommandé)
- Illumination LED blanche intégrée pour des lectures cohérentes
- 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
Pourquoi c'est utile:
- Fonctionne dans diverses conditions d'éclairage grâce aux LED intégrées
- Facile à interfacer avec les broches numériques d'ESP32 C3 Super Mini
- Parfait pour les projets de tri, d'appariement et de détection de couleur
Disposition des broches
Le capteur de couleur TCS3200D/TCS230 a 8 broches de connexion:
- VCC: Entrée d'alimentation (connecter à 5V)
- GND: Connexion de masse (référence 0V)
- S0: Broche de contrôle de l'échelle de fréquence 1
- S1: Broche de contrôle de l'échelle de fréquence 2
- S2: Broche de sélection du filtre de couleur 1
- S3: Broche de sélection du filtre de couleur 2
- OUT: Broche de signal de sortie de fréquence (connecter à une broche numérique ESP32)
- OE: Broche d'activation de sortie (active BAS, généralement connectée à GND)
Comment cela fonctionne
Le capteur de couleur TCS3200 fonctionne en utilisant deux systèmes de contrôle:
Mise à l'échelle de la fréquence (broches S0 et S1):
- S0=BAS, S1=BAS: Mode d'extinction
- S0=BAS, S1=HAUT: Mise à l'échelle de la fréquence à 2%
- S0=HAUT, S1=BAS: Mise à l'échelle de la fréquence à 20%
- S0=HAUT, S1=HAUT: Mise à l'échelle de la fréquence à 100% (recommandé)
Sélection du filtre de couleur (broches S2 et S3):
- S2=BAS, S3=BAS: Filtre rouge actif
- S2=BAS, S3=HAUT: Filtre bleu actif
- S2=HAUT, S3=BAS: Filtre clair (pas de filtrage)
- S2=HAUT, S3=HAUT: Filtre vert actif
Comment fonctionnent les lectures:
- La broche OUT émet un signal d'onde carrée
- La fréquence augmente avec la lumière plus brillante (2 Hz à 500 kHz)
- ESP32 C3 Super Mini mesure la largeur d'impulsion en utilisant pulseIn()
- Les impulsions plus courtes = lumière plus brillante = intensité de couleur plus élevée
- L'étalonnage convertit les largeurs d'impulsion en valeurs RVB standard (0-255)
Maximiser la précision des mesures
Suivez ces conseils pour des lectures précises de couleur TCS3200:
- Gardez la distance du capteur fixe à 1-3 cm de l'objet
- Positionnez le capteur à un angle cohérent (perpendiculaire fonctionne mieux)
- Utilisez les LED blanches intégrées pour une illumination stable
- Protégez le capteur des sources de lumière externes si possible
- Effectuez l'étalonnage dans votre environnement de travail réel
- Testez sur des surfaces planes et mates pour de meilleurs résultats
Schéma de câblage
Connectez le capteur de couleur TCS3200D à votre ESP32 C3 Super Mini en suivant cette simple configuration de câblage:
Note de sécurité:
- Note: Le capteur TCS3200 fonctionne mieux avec une alimentation de 5V, que l'ESP32 C3 Super Mini peut fournir via la broche 5V lors de l'alimentation par USB.
| Capteur de couleur TCS3200 | ESP32 C3 Super Mini |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | D4 |
| S1 | D3 |
| S2 | D6 |
| S3 | D5 |
| OUT | D7 |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Code ESP32 C3 Super Mini - Étalonnage du capteur
Commencez par ce code d'étalonnage pour optimiser votre capteur TCS3200 pour votre environnement spécifique.
Ce que ce code fait:
- Alimente le capteur avec une mise à l'échelle de la 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 continuellement les valeurs d'étalonnage à mesure que vous montrez différentes couleurs
- Affiche les mesures en temps réel dans le moniteur série
/*
* Ce code ESP32 C3 Super Mini a été développé par newbiely.fr
* Ce code ESP32 C3 Super Mini 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-c3/esp32-c3-super-mini-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 4 // The ESP32 C3 SuperMini pin connected to the S0 of the color module
#define PIN_S1 3 // The ESP32 C3 SuperMini pin connected to the S1 of the color module
#define PIN_S2 6 // The ESP32 C3 SuperMini pin connected to the S2 of the color module
#define PIN_S3 5 // The ESP32 C3 SuperMini pin connected to the S3 of the color module
#define PIN_sensorOut 7 // The ESP32 C3 SuperMini 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 C3 Mini? Complétez d'abord notre tutoriel ESP32 C3 Super Mini - Premiers pas pour configurer votre environnement de développement.
- 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 C3 Super Mini sur votre ordinateur via un câble USB-C.
- Ouvrez Arduino IDE: Lancez le logiciel sur votre ordinateur.
- Sélectionnez votre carte: Choisissez ESP32 C3 Super Mini et le port COM correct dans le menu Outils.
- Copiez le code: Collez le code d'étalonnage dans un nouveau sketch Arduino IDE.
- Téléchargez le code: Cliquez sur le bouton Télécharger et attendez la fin du processus.
- Ouvrez le moniteur série: Réglez la vitesse de transmission à 115200 pour afficher les données d'étalonnage.
- Pointez vers des objets blancs: Commencez par du papier blanc brillant ou des surfaces blanches.
- Pointez vers des objets noirs: Déplacez-vous vers des surfaces noires foncées.
- 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 chiffres Min/Max cesseront de changer considérablement.
- Enregistrez vos valeurs: Notez les six chiffres (redMin, redMax, greenMin, greenMax, blueMin, blueMax).
- Conseil pro: Gardez la distance du capteur cohérente (2-3 cm) lors de l'étalonnage pour les résultats les plus précis.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 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 C3 Super Mini - Lecture de couleur RVB
Utilisez ce code pour lire les valeurs de couleur RVB précises après l'étalonnage.
Ce que ce code fait:
- 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 RVB standard (0-255)
- Affiche continuellement les valeurs de couleur dans le moniteur série
- Met à jour les lectures en temps réel à mesure que vous déplacez les objets colorés
/*
* Ce code ESP32 C3 Super Mini a été développé par newbiely.fr
* Ce code ESP32 C3 Super Mini 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-c3/esp32-c3-super-mini-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 4 // The ESP32 C3 SuperMini pin connected to the S0 of the color module
#define PIN_S1 3 // The ESP32 C3 SuperMini pin connected to the S1 of the color module
#define PIN_S2 6 // The ESP32 C3 SuperMini pin connected to the S2 of the color module
#define PIN_S3 5 // The ESP32 C3 SuperMini pin connected to the S3 of the color module
#define PIN_sensorOut 7 // The ESP32 C3 SuperMini 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 C3 Mini? Complétez d'abord notre tutoriel ESP32 C3 Super Mini - Premiers pas pour configurer votre environnement de développement.
- Localisez les variables d'étalonnage: Trouvez ces lignes près du début du code (autour de 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 chiffres que vous avez enregistrés lors de l'étalonnage. Par exemple:
int redMin = 38;
int redMax = 210;
int greenMin = 51;
int greenMax = 185;
int blueMin = 58;
int blueMax = 172;
- Téléchargez le code: Cliquez sur Télécharger pour transférer le code modifié à votre ESP32 C3 Super Mini.
- Ouvrez le moniteur série: Réglez la vitesse de transmission à 115200 pour afficher les valeurs RVB.
- Testez avec des objets colorés: Placez des articles rouges, verts, bleus, jaunes ou d'autres couleurs devant le capteur.
- Lisez les valeurs RVB: Regardez les mesures de couleur se mettre à jour en temps réel sur le moniteur série.
- Conseil pro: Pour des résultats cohérents, maintenez toujours la même distance et les mêmes conditions d'éclairage que ceux utilisés lors de l'étalonnage.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Red = 210 - Green = 35 - Blue = 20
Red = 215 - Green = 38 - Blue = 22
Red = 208 - Green = 33 - Blue = 18
Red = 25 - Green = 200 - Blue = 40
Red = 28 - Green = 205 - Blue = 42
Red = 22 - Green = 198 - Blue = 38
Red = 30 - Green = 45 - Blue = 215
Red = 33 - Green = 48 - Blue = 220
Red = 28 - Green = 42 - Blue = 210
Comprendre la sortie:
- Les valeurs vont de 0 (aucune couleur détectée) à 255 (intensité maximale)
- Les chiffres 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 faibles)
- 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 de projets
Créez des projets créatifs de détection de couleur avec votre ESP32 C3 Super Mini et le capteur TCS3200:
- Trieur de couleurs automatisé: Triez les M&Ms, les briques LEGO ou les perles par couleur à l'aide d'un mécanisme de servo
- Jeu d'appariement de couleurs: Défiez les utilisateurs à trouver des objets correspondant à une valeur RVB cible
- Robot suiveur de ligne: Créez un robot qui suit les chemins de bande colorée sur le sol
- Système de contrôle de qualité: Détectez les produits défectueux en comparant les couleurs aux normes de référence
- Contrôleur d'éclairage intelligent: Ajustez automatiquement les couleurs des LED RVB pour correspondre aux couleurs ambiantes détectées
- Identificateur de couleur de peinture: Créez un appareil portable qui identifie les couleurs de peinture pour la décoration intérieure
- Mélangeur de couleurs éducatif: Démontrez la théorie des couleurs additives en affichant les valeurs RVB des couleurs mélangées
Section Vidéo
Regardez la vidéo ci-dessous pour une visite visuelle de ce projet.
Mettez-vous au défi
Développez vos compétences en matière de capteur de couleur TCS3200 avec ces défis de projet:
- Facile: Ajoutez une LED RVB qui s'illumine avec la même couleur que le capteur détecte
- Facile: Afficher les noms de couleurs ("Red", "Green", "Blue") au lieu de juste des chiffres lorsque les couleurs primaires sont détectées
- Moyen: Construisez un jeu de mémoire des couleurs qui affiche des couleurs aléatoires et teste si les utilisateurs peuvent les assortir
- Moyen: Créez un système de sécurité basé sur les couleurs qui ne se déverrouille que lorsqu'on lui montre un objet d'une couleur spécifique
- Avancé: Construisez un trieur de couleurs complet avec des moteurs servo qui séparent physiquement les objets dans des bacs par couleur
- Avancé: Développez une application pour smartphone qui reçoit les valeurs RVB de l'ESP32 C3 Super Mini via Bluetooth et affiche la couleur réelle sur l'écran