Arduino Nano ESP32 - Capteur de couleur TCS3200D/TCS230
Dans ce tutoriel, nous allons explorer comment connecter le capteur de couleur TCS3200D/TCS230 à Arduino Nano ESP32 pour une détection de couleur précise et une mesure des valeurs RGB.
Ce que vous allez accomplir :
- Connexion du capteur TCS3200D/TCS230 à Arduino Nano ESP32
- Calibration du capteur pour des mesures de couleur précises
- Lecture et affichage des valeurs de couleur RGB
Matériel nécessaire
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 emploie un tableau structuré de 64 photodiodes dans une configuration 8×8 pour la détection optique des couleurs. Le tableau comprend 16 photodiodes avec des filtres optiques rouges, 16 avec des filtres verts, 16 avec des filtres bleus et 16 sans filtres (clairs). La détection de couleur fonctionne en activant des groupes de filtres désignés et en analysant la fréquence de la forme d'onde de sortie.
Les modules capteurs TCS3200D standard intègrent des tableaux de LED blanches qui fournissent un éclairage cohérent à la cible de mesure, offrant des lectures stables dans différents environnements lumineux et permettant le fonctionnement dans des conditions faiblement éclairées.
Brochage
Bornes de connexion sur le module capteur TCS3200D/TCS230 :
- Broche VCC : Alimentation positive (+5V).
- Broche GND : Référence de masse (0V).
- Broches S0, S1 : Broches de configuration de mise à l'échelle de fréquence.
- Broches S2, S3 : Broches d'activation du filtre de couleur.
- Broche OUT : Sortie d'onde carrée encodée en fréquence.
- Broche OE : Broche d'activation de sortie (active quand LOW). Les modules standard la câblent en interne à GND. Si flottante, connecter manuellement à GND.
Comment ça fonctionne
La fonctionnalité du capteur repose sur deux paramètres configurables : quel filtre de couleur activer et quelle plage de fréquence de sortie utiliser. Deux paires de broches de contrôle gèrent ces paramètres :
Configuration de la mise à l'échelle de fréquence (broches S0 et S1) :
- S0=LOW, S1=LOW : Capteur éteint
- S0=LOW, S1=HIGH : Mise à l'échelle de sortie à 2%
- S0=HIGH, S1=LOW : Mise à l'échelle de sortie à 20%
- S0=HIGH, S1=HIGH : Mise à l'échelle de sortie à 100% (fréquence pleine)
Activation du filtre de couleur (broches S2 et S3) :
- S2=LOW, S3=LOW : Tableau de photodiodes rouge actif
- S2=LOW, S3=HIGH : Tableau de photodiodes bleu actif
- S2=HIGH, S3=LOW : Tableau de photodiodes transparent actif (non filtré)
- S2=HIGH, S3=HIGH : Tableau de photodiodes vert actif
La broche OUT génère des fréquences d'onde carrée dans la plage approximative de 2 Hz à 500 kHz. Une intensité lumineuse accrue produit une sortie de fréquence plus élevée. La fonction pulseIn() d'Arduino mesure la durée d'impulsion, qui présente un comportement inverse — un éclairage plus intense donne des durées d'impulsion plus courtes. Grâce à la calibration, ces mesures d'impulsion se transforment en notation RGB familière de 0 à 255.
Maximiser la précision des mesures
- Établir une distance fixe entre le capteur et l'objet (optimal : 1–3 cm) avec un positionnement angulaire stable.
- Activer l'éclairage par LED blanche intégrée pour des résultats reproductibles.
- Se protéger des sources de lumière externe fluctuantes pour une meilleure précision.
Schéma de câblage
Câblez le capteur de couleur TCS3200 à Arduino Nano ESP32 selon cette configuration :
| Capteur de couleur TCS3200 | Arduino Nano ESP32 |
|---|---|
| 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 Arduino Nano ESP32 - Calibration du capteur
La calibration neutralise les facteurs environnementaux affectant les performances du capteur. Des variables telles que l'intensité LED, la proximité de l'objet, les caractéristiques de surface et l'éclairage ambiant affectent toutes les mesures brutes. Ce flux de travail de calibration détermine les durées d'impulsion minimales et maximales pour chaque canal de couleur, créant des limites de référence qui traduisent la sortie brute du capteur en valeurs RGB standardisées de 0 à 255, optimisées pour vos conditions de déploiement.
/*
* Ce code Arduino Nano ESP32 a été développé par newbiely.fr
* Ce code Arduino Nano 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/arduino-nano-esp32/arduino-nano-esp32-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D4 // The Arduino Nano ESP32 pin connected to the S0 of the color module
#define PIN_S1 D3 // The Arduino Nano ESP32 pin connected to the S1 of the color module
#define PIN_S2 D6 // The Arduino Nano ESP32 pin connected to the S2 of the color module
#define PIN_S3 D5 // The Arduino Nano ESP32 pin connected to the S3 of the color module
#define PIN_sensorOut D7 // The Arduino Nano 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
Pour démarrer avec Arduino Nano ESP32, suivez ces étapes :
- Si vous débutez avec Arduino Nano ESP32, consultez le tutoriel sur Installation du logiciel Arduino Nano ESP32..
- Câblez les composants selon le schéma de câblage.
- Connectez la carte Arduino Nano ESP32 à votre ordinateur à l'aide d'un câble USB.
- Lancez Arduino IDE sur votre ordinateur.
- Sélectionnez la carte Arduino Nano ESP32 et son port COM correspondant.
- Copiez le code de calibration et collez-le dans Arduino IDE.
- Cliquez sur le bouton Téléverser pour compiler et téléverser le code.
- Ouvrez le Moniteur Série pour observer la progression de la calibration.
- Dirigez le capteur vers différentes surfaces colorées : matériaux blancs (papier), surfaces noires et divers objets colorés.
- Surveillez les paramètres Min/Max qui se mettent à jour en temps réel.
- Lorsque les valeurs atteignent la stabilité (généralement 10–20 secondes), notez les six numéros de calibration.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Nano ESP32' 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
------------------------------------------
Paramètres de calibration extraits de l'exemple de sortie :
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Code Arduino Nano ESP32 - Lecture de couleur RGB
/*
* Ce code Arduino Nano ESP32 a été développé par newbiely.fr
* Ce code Arduino Nano 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/arduino-nano-esp32/arduino-nano-esp32-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D4 // The Arduino Nano ESP32 pin connected to the S0 of the color module
#define PIN_S1 D3 // The Arduino Nano ESP32 pin connected to the S1 of the color module
#define PIN_S2 D6 // The Arduino Nano ESP32 pin connected to the S2 of the color module
#define PIN_S3 D5 // The Arduino Nano ESP32 pin connected to the S3 of the color module
#define PIN_sensorOut D7 // The Arduino Nano 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 déclarations de variables de calibration au début du code :
int redMin = 0; // Largeur d'impulsion minimale rouge
int redMax = 0; // Largeur d'impulsion maximale rouge
int greenMin = 0; // Largeur d'impulsion minimale verte
int greenMax = 0; // Largeur d'impulsion maximale verte
int blueMin = 0; // Largeur d'impulsion minimale bleue
int blueMax = 0; // Largeur d'impulsion maximale bleue
- Insérez vos valeurs de calibration enregistrées à la place des zéros. Exemple de substitution avec redMin = 42, redMax = 210, greenMin = 55, greenMax = 185, blueMin = 60, blueMax = 172 :
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
- Téléversez le code mis à jour sur Arduino Nano ESP32.
- Placez une cible colorée devant le capteur.
- Ouvrez le Moniteur Série pour voir les mesures RGB.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Nano ESP32' on 'COM15')
New Line
9600 baud
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
Les valeurs RGB de sortie respectent la mise à l'échelle standard de 0 à 255. Des largeurs d'impulsion plus courtes (réflexions intenses) correspondent à des nombres RGB plus élevés ; des largeurs d'impulsion plus longues (réflexions faibles) correspondent à des valeurs plus basses.
Applications de projet
Avec une détection de couleur RGB fonctionnelle, vous pouvez construire :
- Trieur de couleurs automatisé : Classer les objets en fonction de leurs propriétés chromatiques (catégorisation rouge/vert/bleu)
- Outil de comparaison de couleurs : Vérifier la cohérence des couleurs entre plusieurs échantillons
- Navigation guidée par la couleur : Robots qui suivent des voies colorées
- Inspection de fabrication : Identifier les défauts de produit par déviation de couleur
- Contrôle activé par la couleur : Déclencher des comportements spécifiques lorsque des couleurs particulières apparaissent