Raspberry Pi Pico - Capteur de Couleur TCS3200D/TCS230
Ce guide complet vous montre comment connecter le capteur de couleur TCS3200D/TCS230 au Raspberry Pi Pico pour une mesure de couleur précise et l'extraction de valeurs RVB. Maîtrisez les procédures de calibration et développez des capacités de reconnaissance des couleurs dans vos projets.
Objectifs d'apprentissage :
- Établir les connexions entre TCS3200D/TCS230 et Raspberry Pi Pico
- Exécuter la calibration du capteur pour éliminer le bruit environnemental
- Développer des programmes Raspberry Pi Pico pour la mesure de couleur RVB
Matériel Requis
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 capteur TCS3200D/TCS230 utilise une matrice de photodiodes disposées en grille 8×8 pour la détection des couleurs par filtrage optique. Dans ce réseau de 64 éléments, 16 photodiodes comportent des filtres spectraux rouges, 16 autres utilisent des filtres verts, 16 emploient des filtres bleus, et les 16 restantes fonctionnent sans filtres (réponse claire). La mesure des couleurs se fait en activant des ensembles de filtres spécifiques et en analysant la sortie en onde carrée modulée en fréquence.
Les tableaux de LED blanches intégrés sur les modules typiques fournissent un éclairage constant aux cibles, maintenant la stabilité des lectures indépendamment des variations d'éclairage externe et améliorant les performances dans les environnements peu éclairés.
Brochage
Connexions disponibles sur la carte capteur TCS3200D/TCS230 :
- Broche VCC : Entrée de tension d'alimentation (+5V).
- Broche GND : Référence de masse (0V).
- Broches S0, S1 : Sélecteurs de mise à l'échelle de fréquence de sortie.
- Broches S2, S3 : Sélecteurs de filtre de canal de couleur.
- Broche OUT : Sortie en onde carrée modulée en fréquence.
- Broche OE : Entrée d'activation de sortie (s'active quand LOW).
Comment Ça Fonctionne
Contrôle de la mise à l'échelle de fréquence (broches S0 et S1) :
- S0=LOW, S1=LOW : État d'arrêt
- S0=LOW, S1=HIGH : Facteur de mise à l'échelle 2%
- S0=HIGH, S1=LOW : Facteur de mise à l'échelle 20%
- S0=HIGH, S1=HIGH : Facteur de mise à l'échelle 100% (pleine vitesse)
Sélection du canal de couleur (broches S2 et S3) :
- S2=LOW, S3=LOW : Photodiodes rouges actives
- S2=LOW, S3=HIGH : Photodiodes bleues actives
- S2=HIGH, S3=LOW : Photodiodes claires actives (sans filtre)
- S2=HIGH, S3=HIGH : Photodiodes vertes actives
La broche OUT délivre des fréquences en onde carrée. En mesurant la durée d'impulsion (inversement corrélée à l'intensité lumineuse), nous pouvons traduire ces mesures au format RVB standard 0-255 par calibration.
Schéma de Câblage
Configuration de câblage du capteur de couleur TCS3200 vers Raspberry Pi Pico :
| Capteur de Couleur TCS3200 | Raspberry Pi Pico |
|---|---|
| VCC | VBUS (5V) |
| GND | GND |
| OUT | GP9 |
| S0 | GP6 |
| S1 | GP5 |
| S2 | GP8 |
| S3 | GP7 |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Code Raspberry Pi Pico - Calibration par Largeur d'Impulsion
La calibration élimine les interférences environnementales des mesures brutes. La routine de calibration identifie les largeurs d'impulsion minimales et maximales sur tous les canaux de couleur, établissant des limites de référence pour convertir les données brutes en valeurs RVB précises 0–255.
Étapes Rapides
- Connectez votre ordinateur au Raspberry Pi Pico.
- Ouvrez Thonny sur votre PC.
- Allez dans Outils → Options → sélectionnez Interpréteur MicroPython (Raspberry Pi Pico).
- Copiez le code de calibration et téléversez-le sur le Raspberry Pi Pico.
/*
* Ce code Raspberry Pi Pico a été développé par newbiely.fr
* Ce code Raspberry Pi Pico 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/raspberry-pico/raspberry-pi-pico-tcs3200d-tcs230-color-sensor
*/
from machine import Pin
import utime
# Pin Definitions
OUT_PIN = Pin(9, Pin.IN) # GP9 connected to OUT
S0_PIN = Pin(6, Pin.OUT) # GP6 connected to S0
S1_PIN = Pin(5, Pin.OUT) # GP5 connected to S1
S2_PIN = Pin(8, Pin.OUT) # GP8 connected to S2
S3_PIN = Pin(7, Pin.OUT) # GP7 connected to S3
# Set frequency scaling to 20% (S0=HIGH, S1=LOW)
S0_PIN.value(1)
S1_PIN.value(0)
# Variables to track min and max pulse widths for each color
red_min = 999999
red_max = 0
green_min = 999999
green_max = 0
blue_min = 999999
blue_max = 0
def read_pulse_width():
"""Read the pulse width from OUT pin in microseconds"""
# Wait for pulse to start (LOW to HIGH)
timeout = utime.ticks_ms()
while OUT_PIN.value() == 0:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
# Measure HIGH pulse duration
pulse_start = utime.ticks_us()
timeout = utime.ticks_ms()
while OUT_PIN.value() == 1:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
pulse_end = utime.ticks_us()
# Return duration in microseconds
return utime.ticks_diff(pulse_end, pulse_start)
def read_red():
"""Read red color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(0)
utime.sleep_ms(10)
return read_pulse_width()
def read_green():
"""Read green color pulse width"""
S2_PIN.value(1)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
def read_blue():
"""Read blue color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
print("=== TCS3200 Calibration ===")
print("Point the sensor at different objects (white, black, colors).")
print("Min and Max values are tracked automatically.")
print("When values look stable, note them down for the next code.")
print()
try:
while True:
# Read all three colors
red_pw = read_red()
green_pw = read_green()
blue_pw = read_blue()
# Update min values
if red_pw > 0 and red_pw < red_min:
red_min = red_pw
if green_pw > 0 and green_pw < green_min:
green_min = green_pw
if blue_pw > 0 and blue_pw < blue_min:
blue_min = blue_pw
# Update max values
if red_pw > red_max:
red_max = red_pw
if green_pw > green_max:
green_max = green_pw
if blue_pw > blue_max:
blue_max = blue_pw
# Display current readings and min/max
print("-" * 42)
print(f"Red PW = {red_pw} - Green PW = {green_pw} - Blue PW = {blue_pw}")
print(f" Min -> R:{red_min} G:{green_min} B:{blue_min}")
print(f" Max -> R:{red_max} G:{green_max} B:{blue_max}")
utime.sleep_ms(500)
except KeyboardInterrupt:
print("\nCalibration stopped")
print(f"\nFinal calibration values:")
print(f"redMin = {red_min}, redMax = {red_max}")
print(f"greenMin = {green_min}, greenMax = {green_max}")
print(f"blueMin = {blue_min}, blueMax = {blue_max}")
- Exposez le capteur à diverses surfaces : matériaux blancs (papier d'imprimante), objets noirs, plus des articles multicolores.
- Regardez les limites Min/Max se mettre à jour automatiquement.
- Une fois que les valeurs se stabilisent (généralement 10-20 secondes), appuyez sur Ctrl+C pour arrêter.
- Notez les six paramètres de calibration affichés.
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
=== 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
------------------------------------------
Calibration stopped
Final calibration values:
redMin = 42, redMax = 210
greenMin = 55, greenMax = 185
blueMin = 60, blueMax = 172
MicroPython (Raspberry Pi Pico) • Board CDC @ COM29 ≡
Paramètres de calibration extraits de la sortie ci-dessus :
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Code Raspberry Pi Pico - Mesure des Valeurs RVB
Étapes Rapides
- Identifiez les variables de calibration au début du code et remplacez les zéros par vos données de calibration mesurées.
- Téléversez le code sur le Raspberry Pi Pico.
/*
* Ce code Raspberry Pi Pico a été développé par newbiely.fr
* Ce code Raspberry Pi Pico 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/raspberry-pico/raspberry-pi-pico-tcs3200d-tcs230-color-sensor
*/
from machine import Pin
import utime
# Pin Definitions
OUT_PIN = Pin(9, Pin.IN) # GP9 connected to OUT
S0_PIN = Pin(6, Pin.OUT) # GP6 connected to S0
S1_PIN = Pin(5, Pin.OUT) # GP5 connected to S1
S2_PIN = Pin(8, Pin.OUT) # GP8 connected to S2
S3_PIN = Pin(7, Pin.OUT) # GP7 connected to S3
# Calibration values - REPLACE with your calibrated values!
red_min = 0
red_max = 0
green_min = 0
green_max = 0
blue_min = 0
blue_max = 0
# Set frequency scaling to 20% (S0=HIGH, S1=LOW)
S0_PIN.value(1)
S1_PIN.value(0)
def read_pulse_width():
"""Read the pulse width from OUT pin in microseconds"""
# Wait for pulse to start (LOW to HIGH)
timeout = utime.ticks_ms()
while OUT_PIN.value() == 0:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
# Measure HIGH pulse duration
pulse_start = utime.ticks_us()
timeout = utime.ticks_ms()
while OUT_PIN.value() == 1:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
pulse_end = utime.ticks_us()
# Return duration in microseconds
return utime.ticks_diff(pulse_end, pulse_start)
def read_red():
"""Read red color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(0)
utime.sleep_ms(10)
return read_pulse_width()
def read_green():
"""Read green color pulse width"""
S2_PIN.value(1)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
def read_blue():
"""Read blue color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
def map_value(value, in_min, in_max, out_min, out_max):
"""Map value from one range to another"""
if in_max == in_min:
return out_min
return int((value - in_min) * (out_max - out_min) // (in_max - in_min) + out_min)
def constrain(value, min_val, max_val):
"""Constrain value between min and max
"""
return max(min_val, min(value, max_val))
print("TCS3200 Color Sensor - RGB Reading")
print()
try:
while True:
# Read pulse widths for all colors
red_pw = read_red()
green_pw = read_green()
blue_pw = read_blue()
# Convert to 0-255 RGB values
# Lower pulse width = brighter = higher RGB value
red_value = map_value(red_pw, red_min, red_max, 255, 0)
green_value = map_value(green_pw, green_min, green_max, 255, 0)
blue_value = map_value(blue_pw, blue_min, blue_max, 255, 0)
# Constrain to 0-255 range
red_value = constrain(red_value, 0, 255)
green_value = constrain(green_value, 0, 255)
blue_value = constrain(blue_value, 0, 255)
# Display RGB values
print(f"Red = {red_value} - Green = {green_value} - Blue = {blue_value}")
utime.sleep_ms(500)
except KeyboardInterrupt:
print("\nProgram stopped")
- Disposez l'échantillon coloré devant le capteur.
- Vérifiez la sortie RVB dans la Console Thonny.
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
TCS3200 Color Sensor - RGB Reading
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
MicroPython (Raspberry Pi Pico) • Board CDC @ COM29 ≡
Applications de Projet
Avec une capacité de mesure RVB opérationnelle, vous pouvez développer :
- Système de tri chromatique : Catégoriser les objets par couleur (différenciation rouge/vert/bleu)
- Dispositif de vérification des couleurs : Confirmer la cohérence des couleurs entre les échantillons
- Suiveur de chemin coloré : Robots qui naviguent le long de marqueurs chromatiques
- Inspection de qualité visuelle : Détecter les défauts de production par analyse des couleurs
- Automatisation déclenchée par couleur : Exécuter des actions quand des teintes spécifiques sont détectées