Vous êtes sur la page 1sur 19

Interfaçage du capteur de

couleur TCS230 / TCS3200 avec


Arduino

Les capteurs de couleur fournissent des solutions plus fiables aux défis
d'automatisation complexes. Ils sont utilisés dans diverses industries, y
compris les industries de l'alimentation et des boissons, de l'automobile et de
la fabrication à des fins telles que la détection de matériaux, la détection de
marques de couleur sur les pièces, la vérification des étapes du processus de
fabrication, etc.

Alors que des capteurs de couleur coûteux sont utilisés dans les applications
industrielles, des capteurs peu coûteux tels que le capteur de couleur TCS230
peuvent être utilisés pour des applications moins strictes.
Le capteur de couleur TCS230 (également sous la marque TCS3200) est très
populaire, peu coûteux et facile à utiliser. Avant d'utiliser ce capteur de couleur
dans notre projet Arduino, il serait bon de voir comment un capteur de couleur
fonctionne réellement.

Comment fonctionnent les capteurs de


couleur
La lumière blanche est composée de trois couleurs primaires (rouge, vert et
bleu), qui ont des longueurs d'onde différentes. Ces couleurs se combinent
pour former différentes nuances de couleurs.

Lorsque la lumière blanche tombe sur une surface, certaines longueurs d'onde
de la lumière sont absorbées et d'autres sont réfléchies, en fonction des
propriétés du matériau de surface. La couleur que nous voyons est le résultat
de laquelle les longueurs d'onde sont réfléchies dans nos yeux.

Revenant maintenant au capteur, un capteur de couleur typique comprend une


LED blanche à haute intensité qui projette une lumière modulée sur
l'objet. Pour détecter la couleur de la lumière réfléchie, presque tous les
capteurs de couleur se composent d'une grille de filtre sensible à la couleur,
également connu sous le nom de `` filtre Bayer '' et d'un tableau de
photodiodes en dessous, comme le montre l'image ci-dessous.
Un pixel unique est composé de 4 filtres, un filtre rouge, un bleu, un vert et un
filtre clair (pas de filtre). Ce modèle est également connu sous le nom de
« modèle Bayer ». Chaque filtre transmet la lumière d'une seule couleur à la
photodiode en dessous, tandis que le filtre transparent laisse passer la lumière
telle quelle, comme illustré ci-dessous. Cette lumière supplémentaire passée à
travers le filtre transparent est un avantage majeur dans des conditions de
faible luminosité.

La puce de traitement adresse ensuite chaque photodiode (une couleur à la


fois) et mesure l'intensité de la lumière. Comme il existe un réseau de
photodiodes, les résultats sont d'abord moyennés puis envoyés pour
traitement. En mesurant le niveau relatif de lumière rouge, verte et bleue, la
couleur de l'objet est déterminée.
Module de capteur de couleur TCS230
Au cœur du module se trouve une puce de capteur RVB bon marché de Texas
Advanced Optoelectronic Solutions - TCS230. Le capteur de couleur TCS230
est un détecteur de couleur complet qui peut détecter et mesurer une gamme
presque infinie de couleurs visibles.

Le capteur lui-même est visible au centre du module, entouré par les quatre
LED blanches. Les LED s'allument lorsque le module est sous tension et sont
utilisées pour éclairer l'objet détecté. Grâce à ces LED, le capteur peut
également fonctionner dans l'obscurité totale pour déterminer la couleur ou la
luminosité de l'objet.

Le TCS230 fonctionne sur une tension d'alimentation de 2,7 à 5,5 volts et


fournit des sorties de niveau logique TTL.

Fonctionnement du TCS230
Le TCS230 détecte la couleur à l'aide d'un réseau 8 x 8 de photodiodes, dont
seize photodiodes ont des filtres rouges, 16 photodiodes ont des filtres verts,
16 photodiodes ont des filtres bleus et 16 photodiodes restantes sont claires
sans filtre.

Si vous regardez de près le capteur, vous pouvez réellement voir ces filtres.
Chacune des 16 photodiodes est connectée en parallèle, donc en utilisant
deux broches de contrôle S2 et S3, vous pouvez choisir laquelle d'entre elles
lire. Ainsi, par exemple, si vous souhaitez détecter uniquement la couleur
rouge, vous pouvez sélectionner 16 photodiodes filtrées en rouge en
définissant les deux broches sur LOW selon le tableau.

De même, vous pouvez choisir différents types de photodiodes par différentes


combinaisons de S2 et S3.

S2 S3 Type de photodiode

FAIBLE FAIBLE rouge

FAIBLE HAUTE Bleu

HAUTE FAIBLE Effacer (sans filtre)


HAUTE HAUTE Vert

Un convertisseur courant-fréquence interne convertit les lectures des


photodiodes en une onde carrée dont la fréquence est proportionnelle à
l'intensité de la couleur choisie. La plage de fréquence de sortie typique est de
2 HZ ~ 500 KHZ.

Le capteur a deux autres broches de commande, S0 et S1, qui sont utilisées


pour mettre à l'échelle la fréquence de sortie. La fréquence peut être mise à
l'échelle sur trois valeurs préréglées différentes de 2%, 20% ou 100%. Cette
fonction de mise à l'échelle de fréquence permet au capteur d'être utilisé avec
une variété de microcontrôleurs et d'autres appareils.

S0 S1 Mise à l'échelle de la fréquence de sortie

FAIBLE FAIBLE Éteindre

FAIBLE HAUTE 2%

HAUTE FAIBLE 20%

HAUTE HAUTE 100%


Vous pouvez obtenir un facteur d'échelle différent par différentes
combinaisons de S0 et S1. Pour l'Arduino, la plupart des applications utilisent
la mise à l'échelle de 20%.

Brochage du module de capteur de couleur


TCS230
Le schéma suivant montre le brochage d'un module TCS230 commun.

GND est une broche de masse.


OEest la broche d'activation de sortie. Cette broche est rarement utilisée et sur
la plupart des modules est activée en permanence. S'il n'est pas déjà activé,
tirez-le sur BAS.
S0 & S1 les broches sont utilisées pour sélectionner la mise à l'échelle de
fréquence.
S2 & S3 les broches sont utilisées pour sélectionner le tableau de couleurs.
EN DEHORS pin est une onde carrée de niveau TTL.
VCCbroche alimente le module. Connectez-le à l'alimentation 2,7V à 5,5V.

Câblage du capteur de couleur TCS230 à


Arduino UNO
Connecter le TCS 230 à un Arduino est très simple. Chaque broche est utilisée
à l'exception de la broche d'activation de sortie, et le module est alimenté en
toute sécurité à partir de la sortie 5 volts de l'Arduino.

Voici le branchement pour les expériences avec le TCS230:

Aucune des broches utilisées sur l'Arduino n'est critique car le module ne
nécessite aucune fonctionnalité spécifique aux broches, donc si vous
souhaitez utiliser différentes broches, vous pouvez le faire en toute
sécurité. Assurez-vous simplement de changer les numéros de broches dans
le code pour refléter toute modification du câblage.

Une fois que votre capteur est connecté à l'Arduino, il est temps d'écrire du
code!

Calibrage du capteur
Nous utiliserons en fait deux croquis pour travailler avec le capteur de couleur
TCS230.

1. La première esquisse (esquisse d'étalonnage) nous aidera à obtenir les


données brutes du capteur.
2. La deuxième esquisse (esquisse Arduino principale) utilisera les
données brutes précédemment reçues pour afficher les valeurs RVB de la
couleur détectée.

Notez que les deux croquis utiliseront le même raccordement matériel.

Voici le croquis d'étalonnage. Cette esquisse concerne le capteur TCS230


couleur par couleur et lit la largeur d'impulsion de la broche de sortie. La sortie
est alors affichée sur le moniteur série.

Chargez l'esquisse sur votre Arduino et montez le capteur de sorte qu'il soit
face aux objets. Commencez par trouver un objet de référence pour la couleur
blanche et noire. Ces objets de référence produiront des lectures aux valeurs
maximales et minimales pour les trois couleurs.

// Define color sensor pins


#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8

// Variables for Color Pulse Width Measurements


int redPW = 0;
int greenPW = 0;
int bluePW = 0;

void setup() {
// Set S0 - S3 as outputs
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);

// Set Pulse Width scaling to 20%


digitalWrite(S0,HIGH);
digitalWrite(S1,LOW);

// Set Sensor output as input


pinMode(sensorOut, INPUT);
// Setup Serial Monitor
Serial.begin(9600);
}

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);

// Print output to Serial Monitor


Serial.print("Red PW = ");
Serial.print(redPW);
Serial.print(" - Green PW = ");
Serial.print(greenPW);
Serial.print(" - Blue PW = ");
Serial.println(bluePW);
}

// Function to read Red Pulse Widths


int getRedPW() {
// Set sensor to read Red only
digitalWrite(S2,LOW);
digitalWrite(S3,LOW);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

// Function to read Green Pulse Widths


int getGreenPW() {
// Set sensor to read Green only
digitalWrite(S2,HIGH);
digitalWrite(S3,HIGH);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

// Function to read Blue Pulse Widths


int getBluePW() {
// Set sensor to read Blue only
digitalWrite(S2,LOW);
digitalWrite(S3,HIGH);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

Une fois que vous téléchargez le croquis, vous obtiendrez de telles


lectures. Enregistrez les lectures que vous obtenez aux deux extrêmes.
Explication du code:
L'esquisse commence par définir les broches utilisées pour connecter le
TCS230. Certaines variables sont également définies pour représenter les
largeurs d'impulsion du tableau de couleurs rouge, vert et bleu.

#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8

int redPW = 0;
int greenPW = 0;
int bluePW = 0;

Dans la configuration, nous définissons les broches S0-S3 comme des


sorties. Ces broches seront utilisées pour sélectionner la mise à l'échelle de
fréquence et la couleur que nous souhaitons adresser. Les broches S0 et S1
sont utilisées pour régler la mise à l'échelle de fréquence à 20%, ce qui est une
valeur courante lors de l'utilisation de ce capteur de couleur avec un
Arduino. Ensuite, la broche de sortie des capteurs est définie comme une
entrée de l'Arduino, c'est là que nous recevrons l'onde carrée. Enfin, nous
avons mis en place le moniteur série.

void setup() {
// Set S0 - S3 as outputs
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);

// Set Pulse Width scaling to 20%


digitalWrite(S0,HIGH);
digitalWrite(S1,LOW);

// Set Sensor output as input


pinMode(sensorOut, INPUT);

// Setup Serial Monitor


Serial.begin(9600);
}

Dans la section boucle, nous appelons trois


fonctions getRedPW(), getGreenPW()et getBluePW()pour obtenir la largeur
d'impulsion. Examinons à getRedPW()titre d'exemple.

La getRedPW()fonction obtient la largeur d'impulsion rouge. Il commence par


régler les broches S2 et S3 pour sélectionner le filtre rouge. C'est la seule
étape où cette fonction diffère de ses équivalents verts et bleus.

Ensuite, un entier est défini pour stocker la largeur d'impulsion. La largeur


d'impulsion est ensuite déterminée à l'aide de
la pulseIn()fonction Arduino . Cette fonction mesure la largeur d'impulsion,
notez que nous l'avons configurée pour mesurer la largeur de la partie BASSE
de l'impulsion. Le résultat est le temps en millisecondes. Cette valeur est
ensuite renvoyée et la fonction se termine.

int getRedPW() {
// Set sensor to read Red only
digitalWrite(S2,LOW);
digitalWrite(S3,LOW);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

De retour dans la boucle, nous appelons trois fonctions pour lire les largeurs
d'impulsion de couleur, en ajoutant un délai de 200 ms entre elles pour
permettre au capteur de se stabiliser. Nous imprimons ensuite les valeurs sur
le moniteur série et répétons la boucle.

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);

// Print output to Serial Monitor


Serial.print("Red PW = ");
Serial.print(redPW);
Serial.print(" - Green PW = ");
Serial.print(greenPW);
Serial.print(" - Blue PW = ");
Serial.println(bluePW);
}
Code Arduino - Lecture des valeurs RVB du
TCS230
Une fois que vous avez pris vos lectures, vous pouvez télécharger le prochain
croquis où nous lirons les valeurs RVB du capteur de couleur TCS230.

Avant de télécharger l'esquisse, entrez les six valeurs d'étalonnage obtenues à


partir de l'esquisse d'étalonnage en haut de l'esquisse. remplacez le «0» par
vos valeurs réelles.

// Define color sensor pins


#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8

// Calibration Values
// *Get these from Calibration Sketch
int redMin = 0; // Red minimum value
int redMax = 0; // Red maximum value
int greenMin = 0; // Green minimum value
int greenMax = 0; // Green maximum value
int blueMin = 0; // Blue minimum value
int blueMax = 0; // Blue maximum value

// 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(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);

// Set Sensor output as input


pinMode(sensorOut, INPUT);

// Set Frequency scaling to 20%


digitalWrite(S0,HIGH);
digitalWrite(S1,LOW);

// 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(S2,LOW);
digitalWrite(S3,LOW);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

// Function to read Green Pulse Widths


int getGreenPW() {
// Set sensor to read Green only
digitalWrite(S2,HIGH);
digitalWrite(S3,HIGH);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

// Function to read Blue Pulse Widths


int getBluePW() {
// Set sensor to read Blue only
digitalWrite(S2,LOW);
digitalWrite(S3,HIGH);
// Define integer to represent Pulse Width
int PW;
// Read the output Pulse Width
PW = pulseIn(sensorOut, LOW);
// Return the value
return PW;
}

Chargez le croquis et observez les résultats avec des échantillons de


différentes couleurs. Vous pouvez apporter des ajustements mineurs aux
valeurs d'étalonnage si nécessaire.

Explication du code
Vous remarquerez que la majorité de cette esquisse est exactement la même
que l'esquisse précédente, sauf:

Les six valeurs de calibrage que vous avez obtenues à partir de l'esquisse de
calibrage sont entrées dans la partie supérieure de l'esquisse.

// Calibration Values
int redMin = 0; // Red minimum value
int redMax = 0; // Red maximum value
int greenMin = 0; // Green minimum value
int greenMax = 0; // Green maximum value
int blueMin = 0; // Blue minimum value
int blueMax = 0; // Blue maximum value

Trois nouvelles variables sont définies pour les valeurs RVB que nous voulons
générer.

int redValue;
int greenValue;
int blueValue;

Dans la section boucle, nous lisons chacune des valeurs en utilisant la même
fonction que celle utilisée dans l'esquisse précédente. Ensuite, nous utilisons
la map()fonction Arduino pour convertir ces valeurs en valeurs RVB, en utilisant
nos valeurs d'étalonnage comme référence.
Notez que nous avons inversé la plage (la valeur Min est mappée à 255 amd
La valeur Max est mappée à 0) car nos fonctions renvoient la largeur
d'impulsion, pas la fréquence.

// Read Red value


redPW = getRedPW();
// Map to value from 0-255
redValue = map(redPW, redMin,redMax,255,0);
// Delay to stabilize sensor
delay(200);

Enfin, nous sortons les valeurs sur le moniteur série. Ces lectures finales
correspondront aux valeurs RVB de l'élément en cours de numérisation.

Vous aimerez peut-être aussi