Willkommen!

Vielen Dank, dass Sie sich für unser TCS3200 Farbsensor-Modul von AZ-
Delivery entschieden haben. In den nachfolgenden Seiten werden wir Ihnen
erklären wie Sie das Gerät einrichten und nutzen können.

Have fun!
 Inhaltsverzeichnis

Einführung.....................................................................................................3
Technische Daten..........................................................................................4
Pinbelegung..................................................................................................5
Wie man die Arduino IDE einrichtet...............................................................7
Wie man den Raspberry Pi und Python einrichtet.......................................11
Verbindung des Sensors mit dem Atmega328p..........................................12
Sketch-Beispiel........................................................................................13
Verbindung des Sensors mit dem Raspberry Pi..........................................18
Python-Skript...........................................................................................19

-2-
 Einführung

Der TCS3200 Farbsensor ist ein RGB-Farbdetektor, der einen TAOS

TCS3200 RGB-Sensorchip und 4 weiße LEDs enthält. Der Sensor verfügt
über ein 8x8-Array von Fotodioden und einen Strom-zu-Frequenz-Wandler,
in einem Chip integriert. Jede Fotodiode kann mit einem Filter für entweder
eine rote, grüne oder blaue Farbe, oder ohne Filter verwendet werden. Die
Filter jeder Farbe sind gleichmäßig über das Array verteilt, um Verzerrungen
zwischen den Farben zu eliminieren, wie unten abgebildet:

Mit Hilfe des Strom-zu-Frequenz-Wandlers werden die Messwerte der

Fotodioden in eine Rechteckwelle mit einer Frequenz umgewandelt, die
direkt proportional zur Lichtintensität ist.

Der Sensor kann eine Vielzahl von Farben auf der Grundlage ihrer
Wellenlänge erkennen. Mit jedem Filter können Sie nur eine bestimmte
Farblichtintensität messen. Wenn Sie zum Beispiel den roten Filter wählen,
wird nur rotes Licht durchgelassen, Blau und Grün werden nicht gemessen.
Wir erhalten nur die rote Lichtintensität. Genauso können wir mit den
anderen Filtern nur blaue oder grüne Farblichtintensität messen.

-3-
 Technische Daten

» Betriebsspannungsbereich: 2.7V bis 5.5V DC

» Stromversorgung: Power-On-Modus 2mA
Power-Down-Modus 0.1uA
» Betriebstemperaturbereich: -40°C bis 70°C
» Eingänge für die Skalierung der Ausgangsfrequenz: S0 und S1
» Filtertyp-Auswahleingänge: S2 und S3
» Dimensionen: 24 x 20mm [0.95 x 1.2in]
» Hochauflösende Umwandlung von Lichtintensität in Frequenz

Für eine verbesserte Rauschimmunität ist eine elektrische Verbindung mit

niedriger Impedanz zwischen dem OE-Pin und dem GND-Pin des Geräts
erforderlich. Alle Eingangspins müssen entweder durch ein Logiksignal
angesteuert oder mit VDD oder GND verbunden werden. Sie sollten nicht
unverbunden (floating) bleiben.

Der Ausgang des Geräts ist so ausgelegt, dass ein Standard-TTL- oder
CMOS-Logikeingang über kurze Entfernungen angesteuert werden kann.
Wenn am Ausgang Leitungen von mehr als 50mm (12in) verwendet
werden, wird ein Puffer oder ein Linedriver empfohlen.

Ein High-Zustand am OI-Pin versetzt den OUT-Pin in einen Zustand mit

hoher Impedanz.

-4-
 Pinbelegung

Der TCS3200 Farbsensor besitzt acht Pins. Die Pinbelegung ist wie folgt:

Die Ausgabe des Sensors (am OUT-Pin) ist eine Rechteckwelle mit einem
Tastverhältnis von 50% mit einer Frequenz, die direkt proportional zur
Lichtintensität (Bestrahlungsstärke) ist. Die Ausgabefrequenz kann an den
zwei Steuereingangspins, S0 und S1, um einen der drei vorhandenen
Werte skaliert werden.

S0 S1 Scaling Faktor Typ. Frequenz (min)

LOW LOW Power down -
LOW HIGH 2% 12kHz (10kHz)
HIGH LOW 20% 120kHz (100kHz)
HIGH HIGH 100% 600kHz (500kHz)

-5-
Die Pins S2 und S3 werden für die Auswahl des Farbfilters verwendet:
S2 S3 Color filter
LOW LOW Roter
LOW HIGH Blauer
HIGH LOW No filter (clear)
HIGH HIGH Grüner

-6-
 Wie man die Arduino IDE einrichtet

Falls die Arduino-IDE nicht installiert ist, folgen Sie dem link und laden Sie
die Installationsdatei für das Betriebssystem Ihrer Wahl herunter.

Für Windows Benutzer: Doppelklicken Sie auf die heruntergeladene .exe-

Datei und folgen Sie den Anweisungen im Installationsfenster.

-7-
Für Linux Benutzer, laden Sie eine Datei mit der Erweiterung .tar.xz
herunter, die extrahiert werden muss. Wenn sie extrahiert ist, gehen Sie in
das extrahierte Verzeichnis und öffnen Sie das Terminal in diesem
Verzeichnis. Zwei .sh Skripte müssen ausgeführt werden, das erste
namens arduino-linux-setup.sh und das zweite heißt install.sh.

Um das erste Skript im Terminal auszuführen, öffnen Sie das Terminal im

extrahierten Ordner und führen Sie den folgenden Befehl aus:
sh arduino-linux-setup.sh user_name
user_name - ist der Name eines Superusers im Linux-Betriebssystem. Ein
Passwort für den Superuser muss beim Start des Befehls eingegeben
werden. Warten Sie einige Minuten, bis das Skript vollständig
abgeschlossen ist.

Das zweite Skript mit der Bezeichnung install.sh-Skript muss nach der
Installation des ersten Skripts verwendet werden. Führen Sie den folgenden
Befehl im Terminal (extrahiertes Verzeichnis) aus: sh install.sh

Nach der Installation dieser Skripte gehen Sie zu All Apps, wo die
Arduino-IDE installiert ist.

-8-
Fast alle Betriebssysteme werden mit einem vorinstallierten Texteditor
ausgeliefert (z.B. Windows mit Notepad, Linux Ubuntu mit Gedit,
Linux Raspbian mit Leafpad usw.). Alle diese Texteditoren sind für den
Zweck des eBooks vollkommen in Ordnung.

Zunächst ist zu prüfen, ob Ihr PC ein Atmega328p-Board erkennen kann.

Öffnen Sie die frisch installierte Arduino-IDE, und gehen Sie zu:
Tools > Board > {your board name here}
{your board name here} sollte der Arduino/Genuino Uno sein, wie
es auf dem folgenden Bild zu sehen kann:

Der Port, an den das Atmega328p-Board angeschlossen ist, muss

ausgewählt werden. Gehe zu: Tools > Port > {port name goes
here} und wenn das Atmega328p-Board an den USB-Port angeschlossen
ist, ist der Portname im Drop-down Menü auf dem vorherigen Bild zu sehen.

-9-
Wenn die Arduino-IDE unter Windows verwendet wird, lauten die
Portnamen wie folgt:

Für Linux Benutzer, ist zum Beispiel der Portname /dev/ttyUSBx, wobei x
für eine ganze Zahl zwischen 0 und 9 steht.

- 10 -
Wie man den Raspberry Pi und Python einrichtet

Für den Raspberry Pi muss zuerst das Betriebssystem installiert werden,

dann muss alles so eingerichtet werden, dass es im Headless-Modus
verwendet werden kann. Der Headless-Modus ermöglicht eine
Fernverbindung zum Raspberry Pi, ohne dass ein PC-Bildschirm, eine
Maus oder eine Tastatur erforderlich ist. Die einzigen Dinge, die in diesem
Modus verwendet werden, sind der Raspberry Pi selbst, die
Stromversorgung und die Internetverbindung. Das alles wird in dem
kostenlosen eBook ausführlich erklärt:
Raspberry Pi Quick Startup Guide

Das Betriebssystem Raspbian wird mit vorinstalliertem Python

ausgeliefert.

- 11 -
 Verbindung des Sensors mit dem Atmega328p

Verbinden Sie den TCS3200 Farbsensor mit dem Atmega328p, wie unten
abgebildet:

Sensor pin > Mc pin

VCC > 5V Roter Draht
GND > GND Schwarzer Draht
OI > GND Schwarzer Draht
OUT > D6 Blauer Draht
S0 > D3 Lila Draht
S1 > D2 Brauner Draht
S2 > D5 Grüner Draht
S3 > D4 Oranger Draht

- 12 -
Sketch-Beispiel

Für dieses Sketch-Beispiel wird keine externe Library benötigt. Das

Nachfolgende ist Code für das Sketch-Beispiel:
#define S1 2
#define S0 3
#define S3 4
#define S2 5
#define OUT 6
uint16_t frequency = 0;
void stop_all() {
digitalWrite(S0, LOW);
digitalWrite(S1, LOW);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
}
void read_20() { // Setting frequency-scaling to 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
}
void setup() {
Serial.begin(9600);
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(OUT, INPUT);
read_20();
}

- 13 -
void loop() {
read_20();
delay(100);
// Setting Roter filters
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
frequency = pulseIn(OUT, LOW);
Serial.print("Roter = ");
Serial.print(frequency);
Serial.print("\t");
delay(200);
// Setting Grüner filters
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
frequency = pulseIn(OUT, LOW);
Serial.print("Grüner = ");
Serial.print(frequency);
Serial.print("\t");
delay(200);
// Setting Blauer filters
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
frequency = pulseIn(OUT, LOW);
Serial.print("Blauer = ");
Serial.println(frequency);
delay(200);

stop_all();
delay(4000);
}

- 14 -
Laden Sie den Sketch in den Serial Monitor (Tools > Serial Monitor).
Die Ausgabe sollte wie folgt aussehen:

Um diese Werte zu erhalten, legen Sie farbiges Papier mit blauer, roter oder
grüner Farbe vor den Sensor. Die Werte, die nicht ausgewählt werden, sind
die Werte, wenn sich kein Hindernis vor dem Sensor befindet. In der Nähe
des Sensors darf sich außer den On-Board-LEDs des Sensors keine
andere Lichtquelle befinden.

- 15 -
Zu Beginn des Sketches werden fünf Makros erstellt, die digitale E/A-Pin-
Nummern des Atmega328p darstellen, an denen Pins des Sensors
angeschlossen sind. Danach wird die ganzzahlige Variable namens
frequency erstellt. Diese Variable stellt die Ausgangsfrequenz am OUT-
Pin des Sensors dar.

Als nächstes werden zwei Funktionen erstellt. Beide haben keine

Argumente und geben keinen Wert zurück. Die erste Funktion heißt
stop_all() und wird verwendet, um die LEDs eines Sensors
auszuschalten. In der Funktion werden alle digitalen Pins des Atmega328p,
die mit den Pins S0, S1, S2 und S3 des Sensors verbunden sind, in den
Zustand LOW gesetzt.

Die zweite Funktion heißt read_20() aund wird verwendet, um den

Frequenzskalierer auf 20% zu setzen. In der Funktion wird der digitale Pin 3
von dem Atmega328p in den HIGH-Zustand und der digitale Pin 2 in den
LOW-Zustand gesetzt, wodurch der Frequenzskalierer auf 20% gestellt
wird.

In der setup() Funktion beginnt die serielle Kommunikation mit einer

Baudrate von 9600bps. Danach werden die Modi der digitalen Pins 2, 3, 4
und 5 auf OUTPUT und der Modus des digitalen Pins 6 auf INPUT gestellt.
Am Ende dersetup() Funktion wird die read_20() Funktion ausgeführt.

Am Anfang der loop() Funktion wird die read_20() Funktion nochmal

ausgeführt. Das liegt daran, dass die loop() Funktion unbegrenzt loops

- 16 -
macht und am Ende jedes Zyklus die stop_al() Funktion ausgeführt wird,
was den Frequenzskalierer deaktiviert.

- 17 -
Danach werden die Filter für Rot mit folgendem Code ausgewählt:
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);

Als Nächstes wird die pulsein() Funktion verwendet, um die Impulslänge

am OUT-Pin auszulesen. Die pulsein() Funktion hat zwei Argumente
und gibt einen ganzzahligen Wert zurück. Das erste Argument ist die
Pinnummer, an dem der Impuls gemessen wird. Das zweite Argument stellt
die Flanke eines digitalen Signals dar, an der die pulsein() Funktion das
Messen beginnt. Der Wert des zweiten Arguments kann LOW oder HIGH
sein, LOW ist die fallende Grenze des digitalen Signals (Signal ändert
seinen Zustand von HIGH nach LOW) und HIGH die steigende Flanke des
digitalen Signals (Signal ändert seinen Zustand von LOW nach HIGH). Der
Rückgabewert der Funktion, ein ganzzahliger Wert, stellt die Länge des
Impulses in Millisekunden dar. Im Anschluss werden die Daten auf dem
Serial Moniter angezeigt.

Dann werden die Filter auf Grün gestellt. Die Frequenz wird erneut gelesen
und die Daten werden im Serial Monitor angezeigt. Danach wird dasselbe
für den blauen Filter gemacht.

Am Ende der loop() Funktion wir die stop_all() Funktion ausgeführt,

um alle LEDs des Sensors auszuschalten. Danach wird eine
Verzögerungspause von 4 Sekunden eingestellt.

- 18 -
 Verbindung des Sensors mit dem Raspberry Pi

Verbinden Sie den TCS3200 Farbsensor mit dem Raspberry Pi, wie unten
abgebildet:

Sensor pin > Raspberry Pi pin

VCC > 3V3 [pin 17] Roter Draht
GND > GND [pin 9] Schwarzer Draht
OI > GND [pin 9] Schwarzer Draht
OUT > GPIO25 [pin 22] Blauer Draht
S0 > GPIO19 [pin 35] Lila Draht
S1 > GPIO26 [pin 37] Brauner Draht
S2 > GPIO6 [pin 31] Grüner Draht
S3 > GPIO13 [pin 33] Oranger Draht

- 19 -
Python-Skript

Der folgende Code wurde modifiziert und stammt von einem Skript unter
folgendem link.

import RPi.GPIO as GPIO

import time
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
S0 = 19
S1 = 26
S2 = 6
S3 = 13
OUT = 25
NUM_CYCLES = 100
GPIO.setup(OUT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(S0, GPIO.OUT)
GPIO.setup(S1, GPIO.OUT)
GPIO.setup(S2, GPIO.OUT)
GPIO.setup(S3, GPIO.OUT)
def turn_off():
GPIO.output(S0, GPIO.LOW)
GPIO.output(S1, GPIO.LOW)
GPIO.output(S2, GPIO.LOW)
GPIO.output(S3, GPIO.LOW)
def set_scalers():
GPIO.output(S0, GPIO.HIGH)
GPIO.output(S1, GPIO.HIGH)

- 20 -
print('[Press CTRL + C to end the script!]')
try:
set_scalers()
while True:
# setting Roter filters
GPIO.output(S2, GPIO.LOW)
GPIO.output(S3, GPIO.LOW)
time.sleep(0.3)
start = time.time()
for impulse_count in range(NUM_CYCLES):
GPIO.wait_for_edge(OUT, GPIO.FALLING)
duration = time.time() - start # seconds to run for loop
Roter = NUM_CYCLES / duration # in Hz
print('Roter value: {}'.format(Roter))

# setting Blauer filters

GPIO.output(S2, GPIO.LOW)
GPIO.output(S3, GPIO.HIGH)
time.sleep(0.3)
start = time.time()
for impulse_count in range(NUM_CYCLES):
GPIO.wait_for_edge(OUT, GPIO.FALLING)
duration = time.time() - start
Blauer = NUM_CYCLES / duration
print('Blauer value: {}'.format(Blauer))

- 21 -
# two tabs
# setting Grüner filters
GPIO.output(S2, GPIO.HIGH)
GPIO.output(S3, GPIO.HIGH)
time.sleep(0.3)
start = time.time()
for impulse_count in range(NUM_CYCLES):
GPIO.wait_for_edge(OUT, GPIO.FALLING)
duration = time.time() - start
Grüner = NUM_CYCLES / duration
print('Grüner value: {}'.format(Grüner))
time.sleep(2)

print('Turning the LEDs OFF')

turn_off()
time.sleep(4)
print('LEDs turned ON\n')
set_scalers()

except KeyboardInterrupt:
print('\nScript end!')

finally:
turn_off()
GPIO.cleanup()

- 22 -
Speichern Sie das Skript unter dem Namen color.py. Um das Skript
auszuführen, öffnen Sie das Terminal in dem Verzeichnis, in dem das Skript
gespeichert wurde, und führen Sie den folgenden Befehl aus:
python3 color.py

Die Ausgabe sollte wie folgt aussehen:

Um das Skript zu beenden, drücken Sie 'Strg + C' auf der Tastatur.

- 23 -
Das Skript beginnt mit dem Import der zwei Libraries, RPi.GPIO und time.

Geben Sie dem GPIO-Pin den Namen "BCM" und alle Warnungen bei der
Verwendung von GPIO-Schnittstellen werden deaktiviert.

Dann werden sechs Variablen erstellt, wobei die Variablen S0, S1, S2, S3
und OUT die Pins des Raspberry Pi darstellen, an denen die Pins des
Sensors verbunden werden. Die sechste Variable heißt NUM_CYCLES und
wird verwendet, um die Frequenz der Impulse am OUT-Pin auszulesen. Je
höher der Wert in der NUM_CYCLES Variable, desto genauer ist das
Ergebnis.

Danach werden die Pinmodi für die S0, S1, S2, S3 und OUT-Pins eingestellt
(S0, S1, S2 und S3 zu OUTPUT, und der OUT-Pin zu INPUT).

Als Nächstes werden zwei Funktionen erstellt, ohne Argumente und

Rückgabewert.

Die erste Funktion heißt turn_off() und dient dem Ausschalten der LEDs
auf dem Sensor. In der Funktion werden die Zustände der Pins S0, S1, S2
und S3 auf LOW gestellt.

Die zweite Funktion heißt set_scalers().Mit ihr wird der

Frequenzskalierer des Sensors eingestellt. In der Funktion werden die Pins
S0 and S1 auf HIGH gestellt, was den Frequenzskalierer auf 100%
einstellt (keine Skalierung).

- 24 -
Als Nächstes wird der try-except-finally Codeblock erstellt. In dem
try Codeblod wird als Erstes die set_scalers() Funktion ausgeführt,
wodurch im Anschluss der Indefinite loop Codeblock erstellt wird (while
True:). In dem Indefinite loop Codeblock geschieht dasselbe wie in der
loop() Funktion des Atmega328p. Die Filter für die Rot werden eingestellt,
dann werden die Impulse ausgelesen und die Daten werden angezeigt.
Dasselbe geschieht bei den blauen und grünen Filtern. Am Ende des
Indefinite Codeblocks wir die turn_off() Funktion ausgeführt, um die
LEDs des Sensors auszuschalten. Danach wird eine Verzögerungszeit von
4 Sekunden eingestellt und die set_scalers() Funktion wird ausgeführt.

Um das Skript zu beenden, drücken Sie STRG + C auf der Tastatur. Das
wird Keyboard Interrupt genannt. Wenn das passiert wird der except
Codeblock ausgeführt und die Nachricht Script end! wird im Terminal
angezeigt.

Der finally Codeblock wird am Ende des Skripts ausgeführt. Darin

werden die turn_off() und cleanup() Funktionen ausgeführt, um alle
GPIO-Schnittstellen auszuschalten und alle verwendeten GPIO-Pins des
Raspberry Pi zu deaktivieren.

Sie haben es geschafft. Sie können jetzt unser

Modul für Ihre Projekte nutzen.

- 25 -
Jetzt sind Sie dran! Entwickeln Sie Ihre eigenen Projekte und Smart- Home
Installationen. Wie Sie das bewerkstelligen können, zeigen wir Ihnen
unkompliziert und verständlich auf unserem Blog. Dort bieten wir Ihnen
Beispielskripte und Tutorials mit interessanten kleinen Projekten an, um
schnell in die Welt der Mikroelektronik einzusteigen. Zusätzlich bietet Ihnen
auch das Internet unzählige Möglichkeiten, um sich in Sachen
Mikroelektronik weiterzubilden.

Falls Sie nach weiteren Hochwertige Mikroelektronik und Zubehör,

sind Sie bei der AZ-Delivery Vertriebs GmbH goldrichtig. Wir bieten
Ihnen zahlreiche Anwendungsbeispiele, ausführliche
Installationsanleitungen, Ebooks, Bibliotheken und natürlich die
Unterstützung unserer technischen Experten.

https://az-delivery.de
Viel Spaß!
Impressum
https://az-delivery.de/pages/about-us

- 26 -