SENSOREN/ACTUATOREN

Raspberry Pi - TCS3200D/TCS230 Kleursensor

Deze uitgebreide handleiding laat u zien hoe u de TCS3200D/TCS230 kleursensor aansluit op de Raspberry Pi voor nauwkeurige kleurmeting en het uitlezen van RGB-waarden. Beheers de kalibratieprocedures en ontwikkel kleurherkenningsfuncties voor uw projecten.

Leerdoelen:

Verbindingen tot stand brengen tussen de TCS3200D/TCS230 en Raspberry Pi
Sensor kalibreren om omgevingsruis te elimineren
Raspberry Pi programma’s ontwikkelen voor RGB-kleurmeting

Raspberry Pi met TCS3200D TCS230 kleursensor module tutorial

Hardware Benodigd

1	×	Raspberry Pi 5
1	×	TCS3200D/TCS230 Color Recognition Sensor Module
1	×	Breadboard (experimenteerprint)
1	×	Jumper wires (verbindingsdraden)
1	×	(Aanbevolen) Schroefklem Block Shield voor Raspberry Pi
1	×	(Aanbevolen) Raspberry Pi Prototyping Basisplaat & Breadboard Kit
1	×	(Aanbevolen) HDMI-Touchscreen-Monitor voor Raspberry Pi

Of u kunt de volgende kits kopen:

1	×	DIYables Sensorkit (30 sensoren/displays)
1	×	DIYables Sensorkit (18 sensoren/displays)

Openbaarmaking: Sommige van de links in deze sectie zijn Amazon-affiliate links. We kunnen een commissie ontvangen voor aankopen die via deze links worden gedaan, zonder extra kosten voor u. We waarderen uw steun.

Over de TCS3200D/TCS230 Kleursensor

De TCS3200D/TCS230 sensor maakt gebruik van een fotodiode-matrix die is georganiseerd in een 8×8 raster voor kleurdetectie door middel van optische filtering. Binnen deze array met 64 elementen bevatten 16 fotodiodes rode spectrale filters, nog eens 16 gebruiken groene filters, 16 hebben blauwe filters en de resterende 16 werken zonder filter (heldere respons). Kleurmeting vindt plaats door specifieke filtersets te activeren en de resulterende frequentie-gemoduleerde vierkante golf uitgang te analyseren.

Typische modules zijn uitgerust met ingebouwde witte LED-arrays die zorgen voor constante verlichting van het meetobject, wat de stabiliteit van metingen garandeert ongeacht variaties in externe lichtbronnen en de prestaties verbetert in omgevingen met weinig licht.

Pin-out

Beschikbare aansluitingen op het TCS3200D/TCS230 sensorbord:

VCC pin: Voedingsspanning invoer (+5V)
GND pin: Massa (0V)
S0, S1 pins: Selectoren voor de schaal van de frequentie-uitgang
S2, S3 pins: Selectoren voor het kleurkanaal/filter
OUT pin: Frequentie-gemoduleerde vierkante golf uitgang
OE pin: Ingang om uitgang te activeren (actief bij LOW). Standaardmodules hebben deze pin intern doorverbonden met GND. Als dit niet het geval is, sluit deze dan handmatig aan op GND.

TCS3200 TCS230 kleurensensor module pinout schema met VCC GND S0 S1 S2 S3 OUT pins

Hoe Werkt Het

Twee belangrijke instellingen bepalen het gedrag van de sensor: welk kleurkanaal wordt geactiveerd en welke uitgangssignaalsterkte wordt gegenereerd. Twee paar controlinputs regelen deze functies:

Frequentieschaalbesturing (S0 en S1 pins):

S0=LOW, S1=LOW: Uitschakeling (power down)
S0=LOW, S1=HIGH: 2% schaalfactor
S0=HIGH, S1=LOW: 20% schaalfactor
S0=HIGH, S1=HIGH: 100% schaalfactor (volledige snelheid)

Kleurkanaalselectie (S2 en S3 pins):

S2=LOW, S3=LOW: Rode fotodiodes actief
S2=LOW, S3=HIGH: Blauwe fotodiodes actief
S2=HIGH, S3=LOW: Heldere fotodiodes actief (zonder filtering)
S2=HIGH, S3=HIGH: Groene fotodiodes actief

De OUT-pin levert vierkante golffrequenties in een bereik van ongeveer 2 Hz tot 500 kHz. De frequentie neemt toe met de lichtintensiteit – helderder licht levert hogere frequenties. Door de pulsduur te meten (die omgekeerd evenredig is, kortere duur betekent sterker licht) kunnen we deze metingen met kalibratie omzetten naar het gangbare 0–255 RGB-formaat.

Optimale Precisie Bereiken

Houd de sensor 1-3 cm van het meetobject met stabiele hoekuitlijning
Gebruik de geïntegreerde witte LED-verlichting voor reproduceerbare lichtomstandigheden
Bescherm de sensor tegen wisselend omgevingslicht voor consistente metingen

Bedradingsschema

Aansluitschema TCS3200 kleursensor op Raspberry Pi:

TCS3200 Color Sensor	Raspberry Pi
VCC	5V
GND	GND
OUT	GPIO23
S0	GPIO8
S1	GPIO7
S2	GPIO24
S3	GPIO25

Raspberry Pi en TCS3200 kleursensor bedrading schema met verbindingen tussen pins

This image is created using Fritzing. Click to enlarge image

Raspberry Pi Code - Pulsbreedte Kalibratie

Kalibratie elimineert omgevingsinvloeden uit ruwe metingen. Variabelen zoals LED-uitgangssterkte, afstand tot het meetobject, materiaalreflectie en kamerlicht beïnvloeden de uitlezing. Zie dit als systematische fouten die gemeten moeten worden. De kalibratieroutine vindt de minimum en maximum pulsbreedtes van alle kleurkanalen, waarmee referentiegrenzen worden vastgesteld om ruwe data nauwkeurig om te rekenen naar 0–255 RGB-waarden, passend bij uw omgeving.

# Deze Raspberry Pi code is ontwikkeld door newbiely.nl # Deze Raspberry Pi code wordt zonder enige beperking aan het publiek beschikbaar gesteld. # Voor volledige instructies en schema's, bezoek: # https://newbiely.nl/tutorials/raspberry-pi/raspberry-pi-tcs3200d-tcs230-color-sensor import RPi.GPIO as GPIO import time # Pin Definitions (all on same physical row for easy wiring) OUT_PIN = 23 # Raspberry Pi GPIO23 pin connected to OUT (physical pin 16) S0_PIN = 8 # Raspberry Pi GPIO8 pin connected to S0 (physical pin 24) S1_PIN = 7 # Raspberry Pi GPIO7 pin connected to S1 (physical pin 26) S2_PIN = 24 # Raspberry Pi GPIO24 pin connected to S2 (physical pin 18) S3_PIN = 25 # Raspberry Pi GPIO25 pin connected to S3 (physical pin 22) # Set up GPIO mode GPIO.setmode(GPIO.BCM) GPIO.setup(S0_PIN, GPIO.OUT) GPIO.setup(S1_PIN, GPIO.OUT) GPIO.setup(S2_PIN, GPIO.OUT) GPIO.setup(S3_PIN, GPIO.OUT) GPIO.setup(OUT_PIN, GPIO.IN) # Set frequency scaling to 2% (S0=LOW, S1=HIGH) for reliable timing on Raspberry Pi GPIO.output(S0_PIN, GPIO.LOW) GPIO.output(S1_PIN, GPIO.HIGH) # 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 go HIGH timeout = time.time() + 0.1 # 100ms timeout while GPIO.input(OUT_PIN) == GPIO.LOW: if time.time() > timeout: return 0 # Measure HIGH pulse duration pulse_start = time.time() timeout = time.time() + 0.1 while GPIO.input(OUT_PIN) == GPIO.HIGH: if time.time() > timeout: return 0 pulse_end = time.time() # Return duration in microseconds return int((pulse_end - pulse_start) * 1000000) def read_red(): """Read red color pulse width """ GPIO.output(S2_PIN, GPIO.LOW) GPIO.output(S3_PIN, GPIO.LOW) time.sleep(0.01) return read_pulse_width() def read_green(): """Read green color pulse width""" GPIO.output(S2_PIN, GPIO.HIGH) GPIO.output(S3_PIN, GPIO.HIGH) time.sleep(0.01) return read_pulse_width() def read_blue(): """Read blue color pulse width """ GPIO.output(S2_PIN, GPIO.LOW) GPIO.output(S3_PIN, GPIO.HIGH) time.sleep(0.01) return read_pulse_width() try: 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() while True: # Read all three colors (average of 3 readings for stability) red_readings = [read_red() for _ in range(3)] green_readings = [read_green() for _ in range(3)] blue_readings = [read_blue() for _ in range(3)] red_pw = sum(r for r in red_readings if r > 0) // max(1, len([r for r in red_readings if r > 0])) green_pw = sum(g for g in green_readings if g > 0) // max(1, len([g for g in green_readings if g > 0])) blue_pw = sum(b for b in blue_readings if b > 0) // max(1, len([b for b in blue_readings if b > 0])) # 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}") time.sleep(0.5) 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}") finally: GPIO.cleanup()

Snel aan de slag

Kopieer de code en sla deze op in een bestand, bijvoorbeeld tcs3200_calibration.py
Voer het script uit:

PuTTY - Raspberry Pi

python3 tcs3200_calibration.py

Richt de sensor op verschillende oppervlakken: witte materialen (printerpapier), zwarte voorwerpen, en meerkleurige objecten
Kijk hoe Min/Max grenzen automatisch worden bijgewerkt wanneer extremen worden gedetecteerd
Zodra de waarden stabiel lijken (meestal na 10-20 seconden), druk op Ctrl+C om te stoppen
Noteer alle zes kalibratieparameters die worden weergegeven

PuTTY - Raspberry Pi

=== 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 ------------------------------------------ Calibration stopped Final calibration values: redMin = 42, redMax = 210 greenMin = 55, greenMax = 185 blueMin = 60, blueMax = 172

Voorbeeld kalibratieparameters uit bovenstaande output:

RedMin = 42, redMax = 210
GreenMin = 55, greenMax = 185
BlueMin = 60, blueMax = 172

Raspberry Pi Code - RGB Waarde Meting

# Deze Raspberry Pi code is ontwikkeld door newbiely.nl # Deze Raspberry Pi code wordt zonder enige beperking aan het publiek beschikbaar gesteld. # Voor volledige instructies en schema's, bezoek: # https://newbiely.nl/tutorials/raspberry-pi/raspberry-pi-tcs3200d-tcs230-color-sensor import RPi.GPIO as GPIO import time # Pin Definitions (all on same physical row for easy wiring) OUT_PIN = 23 # Raspberry Pi GPIO23 pin connected to OUT (physical pin 16) S0_PIN = 8 # Raspberry Pi GPIO8 pin connected to S0 (physical pin 24) S1_PIN = 7 # Raspberry Pi GPIO7 pin connected to S1 (physical pin 26) S2_PIN = 24 # Raspberry Pi GPIO24 pin connected to S2 (physical pin 18) S3_PIN = 25 # Raspberry Pi GPIO25 pin connected to S3 (physical pin 22) # 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 up GPIO mode GPIO.setmode(GPIO.BCM) GPIO.setup(S0_PIN, GPIO.OUT) GPIO.setup(S1_PIN, GPIO.OUT) GPIO.setup(S2_PIN, GPIO.OUT) GPIO.setup(S3_PIN, GPIO.OUT) GPIO.setup(OUT_PIN, GPIO.IN) # Set frequency scaling to 2% (S0=LOW, S1=HIGH) for reliable timing on Raspberry Pi GPIO.output(S0_PIN, GPIO.LOW) GPIO.output(S1_PIN, GPIO.HIGH) def read_pulse_width(): """Read the pulse width from OUT pin in microseconds""" # Wait for pulse to go HIGH timeout = time.time() + 0.1 # 100ms timeout while GPIO.input(OUT_PIN) == GPIO.LOW: if time.time() > timeout: return 0 # Measure HIGH pulse duration pulse_start = time.time() timeout = time.time() + 0.1 while GPIO.input(OUT_PIN) == GPIO.HIGH: if time.time() > timeout: return 0 pulse_end = time.time() # Return duration in microseconds return int((pulse_end - pulse_start) * 1000000) def read_red(): """Read red color pulse width """ GPIO.output(S2_PIN, GPIO.LOW) GPIO.output(S3_PIN, GPIO.LOW) time.sleep(0.01) return read_pulse_width() def read_green(): """Read green color pulse width""" GPIO.output(S2_PIN, GPIO.HIGH) GPIO.output(S3_PIN, GPIO.HIGH) time.sleep(0.01) return read_pulse_width() def read_blue(): """Read blue color pulse width """ GPIO.output(S2_PIN, GPIO.LOW) GPIO.output(S3_PIN, GPIO.HIGH) time.sleep(0.01) 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)) try: print("TCS3200 Color Sensor - RGB Reading") print() while True: # Read pulse widths for all colors (average of 3 readings for stability) red_readings = [read_red() for _ in range(3)] green_readings = [read_green() for _ in range(3)] blue_readings = [read_blue() for _ in range(3)] red_pw = sum(r for r in red_readings if r > 0) // max(1, len([r for r in red_readings if r > 0])) green_pw = sum(g for g in green_readings if g > 0) // max(1, len([g for g in green_readings if g > 0])) blue_pw = sum(b for b in blue_readings if b > 0) // max(1, len([b for b in blue_readings if b > 0])) # 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}") time.sleep(0.5) except KeyboardInterrupt: print("\nProgram stopped") finally: GPIO.cleanup()

Snel aan de slag

Zoek in het begin van de code de kalibratievariabelen:

red_min = 0 red_max = 0 green_min = 0 green_max = 0 blue_min = 0 blue_max = 0

Vervang alle zes nulwaarden door de gemeten kalibratiedata. Voorbeeld met waarden redMin = 42, redMax = 210, greenMin = 55, greenMax = 185, blueMin = 60, blueMax = 172:

red_min = 42 red_max = 210 green_min = 55 green_max = 185 blue_min = 60 blue_max = 172

Sla de aangepaste code op, bijvoorbeeld als tcs3200_sensor.py
Voer het script uit:

PuTTY - Raspberry Pi

python3 tcs3200_sensor.py

Plaats een gekleurd proefobject voor de sensor
Bekijk de RGB-uitvoer in de terminal

PuTTY - Raspberry Pi

TCS3200 Color Sensor - RGB Reading Red = 210 - Green = 35 - Blue = 20 Red = 25 - Green = 200 - Blue = 40 Red = 30 - Green = 45 - Blue = 215

De weergegeven RGB-waarden zijn conform de standaard 0-255 schaal. Kortere pulsbreedtes (duidend op helder reflecterend licht) geven hogere RGB-waarden; langere pulsbreedtes (minder reflectie) resulteren in lagere waarden.

Project Toepassingen

Met een operationele RGB-meting kunt u ontwikkelen:

Chromatisch sorteersysteem: Objecten categoriseren op kleur (rood/groen/blauw onderscheid)
Kleurverificatie-apparaat: Consistentie van kleuren tussen monsters bevestigen
Gekleurde routevolger: Robots die lijnen of markers in diverse kleuren volgen
Visuele kwaliteitscontrole: Productiefouten detecteren via kleuranalyse
Kleurgestuurde automatisering: Acties uitvoeren bij detectie van specifieke kleuren

Video Tutorial

We overwegen het maken van videotutorials. Als u videotutorials belangrijk vindt, abonneer u dan op ons YouTube-kanaal om ons te motiveren de video's te maken.

Bekijk onze video-tutorial voor een visuele begeleiding bij dit project! De video biedt extra inzichten en aanvullingen bij het gebruik en de toepassing van de TCS3200D/TCS230 kleursensor met Raspberry Pi.

Gerelateerde Tutorials

※ ONZE BERICHTEN

U bent welkom om de link naar deze tutorial te delen. Gebruik onze inhoud echter niet op andere websites. We hebben veel moeite en tijd gestoken in het maken van de inhoud, respecteer alstublieft ons werk!