In diesem Beitrag möchte ich dir den kleinen, günstigen Farbsensor TCS34725 vorstellen und zeigen, wie du diesen am Arduino UNO R3 anschließt und programmierst. Im Beitrag Arduino Lektion 60: Sensor für Licht, Farbe und Gesten (APDS-9960) habe ich dir bereits ein multifunktionales Modul vorgestellt, welches ebenso die Farbe erkennen kann. Dieser Sensor stellt jedoch eine günstige Alternative dar, wenn man lediglich das Feature der Farberkennung benötigt.
Der TCS34725 überzeugt durch seine einfache Integration über die I2C-Schnittstelle und die umfangreiche Unterstützung durch Bibliotheken wie die von Adafruit. Mit diesem Sensor lassen sich präzise RGB-Werte und Umgebungslichtdaten messen, was ihn ideal für Projekte wie Farbkalibrierung, Beleuchtungsautomatisierung oder DIY-Roboter macht.
In diesem Beitrag zeige ich dir nicht nur, wie du den Sensor anschließt, sondern auch, wie du die erfassten Farbwerte in deinem Projekt nutzen kannst. Als praktisches Beispiel verbinden wir eine RGB-LED, die die vom Sensor erkannten Farben in Echtzeit darstellt. So kannst du die Farberkennung auf anschauliche Weise erleben.
Inhaltsverzeichnis
- Bezug des Farbsensors TCS34725
- Aufbau des Farbsensors
- Anschluss des Farbsensors TCS34725 via I2C an den Arduino
- Programmieren des Farbsensors TCS34725 am Arduino UNO R3
- Erweitern der Schaltung um einen Abstandssensor um die LEDs / den Sensor zu aktivieren
Bezug des Farbsensors TCS34725
Den hier vorgestellten Farbsensor bekommst du sehr günstig auf den einschlägigen Plattformen.
- ebay.de* – ab 2,32 €
- aliexpress.com – 2,59 €
- amazon.de* – 3 €
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Aufbau des Farbsensors
Der Farbsensor verfügt über eine I2C Schnittstelle und kann mit 5 V und 3.3V betrieben werden. Die beiden sehr leuchtstarken LEDs sind dauerhaft aktiv, können aber nach Bedarf über den Pin LED deaktiviert werden.
Anschluss des Farbsensors TCS34725 via I2C an den Arduino
Durch die erwähnte I2C Schnittstelle ist der Anschluss an den Arduino sehr einfach und wir benötigen für diesen lediglich vier Breadboardkabel. Zusätzlich zum Farbsensor wird eine RGB-LED integriert, die die vom Sensor erkannten Farben visuell darstellt.
Für den Aufbau der Schaltung am Arduino benötigst du:
- einen Arduino kompatiblen Mikrocontroller
- ein passendes Datenkabel*
- diverse Breadboardkabel*, männlich – männlich, 10 cm
- ein 170 Pin / 400 Pin Breadboard*
- eine RGB LED 5050*
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Programmieren des Farbsensors TCS34725 am Arduino UNO R3
Für die Programmierung des Arduino verwende ich die Arduino IDE 2.3.3 welche du unter https://www.arduino.cc/en/software für Windows, macOS und Linux herunterladen kannst.
Für das Ansteuern / auslesen des Farbsensors benötigen wir zusätzlich eine Bibliothek, hier gibt es diverse auf dem Markt welche ebenso kostenfrei erhältlich sind. Ich habe mit der Adafruit TCS34725 erfolgreich die Farbe auslesen können und möchte dir diese herzlich empfehlen.
Um die Bibliothek zu installieren, musst du links den Bibliotheksverwalter (1) öffnen und dort nach „Adafruit TCS34725“ (2) suchen. Im ersten Eintrag wählst du hier die Schaltfläche „INSTALLIEREN“ (3). Diese Bibliothek hat eine Abhängigkeit zu Adafruit BusIO welches wir ebenso installieren müssen, daher klicken wir in dem Dialog ebenso auf „ALLE INSTALLIEREN“ (4)
Nachfolgend möchte ich dir zeigen, wie du die Farbe auslesen und auf einer RGB LED darstellen kannst. Es wird zunächst nur die Farbe Rot, Grün und Blau dargestellt.
// Bibliotheken zur Steuerung und Auslesung des Farbsensors
#include <Wire.h>
#include "Adafruit_TCS34725.h"
// Pins, an denen die RGB-LED angeschlossen ist
#define red 10
#define green 9
#define blue 11
// Instanziieren eines Objekts vom Typ Adafruit_TCS34725 mit spezifischen Parametern
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_614MS, TCS34725_GAIN_1X);
// Variablen zum Speichern der Farbdaten und Lichtwerte
uint16_t r, g, b, c, colorTemp, lux;
void setup(void) {
// Starten der seriellen Kommunikation mit einer Baudrate von 9600
Serial.begin(9600);
// Definieren der LED-Pins als Ausgänge
pinMode(red, OUTPUT);
pinMode(green, OUTPUT);
pinMode(blue, OUTPUT);
// Initialisieren der Kommunikation mit dem Farbsensor
tcs.begin();
}
void loop(void) {
// Auslesen der Rohdaten (Rot, Grün, Blau, Klarheit) vom Sensor
tcs.getRawData(&r, &g, &b, &c);
// Berechnen der Farbtemperatur in Kelvin
colorTemp = tcs.calculateColorTemperature_dn40(r, g, b, c);
// Berechnen der Beleuchtungsstärke (Lux)
lux = tcs.calculateLux(r, g, b);
// Berechnen der RGB-Werte für Rot, Grün und Blau basierend auf den Rohdaten
byte rgbColorRed = calcColorValue(r, c);
byte rgbColorGreen = calcColorValue(g, c);
byte rgbColorBlue = calcColorValue(b, c);
// Vergleichen der RGB-Werte, um die dominante Farbe zu ermitteln
byte maxColor = compareValues(rgbColorRed, rgbColorGreen, rgbColorBlue);
// Überprüfen, welche der Farben (Rot, Grün, Blau) dominiert
bool isMainColorRed = maxColor == rgbColorRed;
bool isMainColorGreen = maxColor == rgbColorGreen;
bool isMainColorBlue = maxColor == rgbColorBlue;
// Setzen der LED-Farben basierend auf der dominanten Farbe
analogWrite(red, isMainColorRed ? 255 : 0);
analogWrite(green, isMainColorGreen ? 255 : 0);
analogWrite(blue, isMainColorBlue ? 255 : 0);
// Ausgabe der Farbtemperatur und Lux-Werte auf der seriellen Schnittstelle
Serial.println("Color Temp: " + String(colorTemp, DEC) + " K");
Serial.println("Lux: " + String(lux, DEC));
Serial.println("Rot: " + String(r, DEC));
Serial.println("Grün: " + String(g, DEC));
Serial.println("Blau: " + String(b, DEC));
Serial.println("Klarheit: " + String(c, DEC));
// Ausgabe der berechneten RGB-Werte auf der seriellen Schnittstelle
Serial.print("RGB-Wert: (" + String(rgbColorRed, DEC) + "," + String(rgbColorGreen) + "," + String(rgbColorBlue) + ")");
}
// Berechnet den RGB-Wert aus einem Farbwert (Rot, Grün oder Blau) und dem Klarheitswert
uint16_t calcColorValue(uint16_t color, uint16_t clarityValue) {
double rgbColorValue = (double)color / (double)clarityValue;
return round(rgbColorValue * 255);
}
// Vergleicht die RGB-Werte und gibt die dominante Farbe zurück
byte compareValues(byte r, byte g, byte b) {
if (r > g && r > b) {
return r;
} else if (g > r && g > b) {
return g;
} else if (b > r && b > g) {
return b;
}
return 0;
}
Umrechnen des Farbwertes in RGB Werte
Vom Sensor erhalten wir lediglich die Rohdaten für die Farbinformationen um daraus einen RGB Wert zu berechnen nutze ich nachfolgende Formel:
Bedeutung der Variablen:
- 255: Die maximale RGB-Wert-Skala, auf die die Werte angepasst werden.
- Farbwert (
color): Der Rohwert eines Farbkanals (Rot, Grün oder Blau), den der Sensor liefert. - Klarheitswert (
clarityValue): Ein Maß für die Gesamtlichtintensität (Summe aller Farben und Helligkeit), um die Farbe zu normalisieren.
// Berechnet den RGB-Wert aus einem Farbwert (Rot, Grün oder Blau) und dem Klarheitswert
uint16_t calcColorValue(uint16_t color, uint16_t clarityValue) {
double rgbColorValue = (double)color / (double)clarityValue;
return round(rgbColorValue * 255);
}
Ermitteln der Farbe (einfache Lösung)
Zunächst konzentriere ich mich darauf, die drei Grundfarben Rot, Grün und Blau darzustellen. Dafür verwende ich zu Beginn drei einfarbige Würfel in Rosa, Grün und Blau. Anhand der berechneten RGB-Werte lässt sich die dominante Farbe bestimmen, die dann über die RGB-LED visualisiert wird.
// Berechnen der RGB-Werte für Rot, Grün und Blau basierend auf den Rohdaten byte rgbColorRed = calcColorValue(r, c); byte rgbColorGreen = calcColorValue(g, c); byte rgbColorBlue = calcColorValue(b, c); // Vergleichen der RGB-Werte, um die dominante Farbe zu ermitteln byte maxColor = compareValues(rgbColorRed, rgbColorGreen, rgbColorBlue); // Überprüfen, welche der Farben (Rot, Grün, Blau) dominiert bool isMainColorRed = maxColor == rgbColorRed; bool isMainColorGreen = maxColor == rgbColorGreen; bool isMainColorBlue = maxColor == rgbColorBlue; // Setzen der LED-Farben basierend auf der dominanten Farbe analogWrite(red, isMainColorRed ? 255 : 0); analogWrite(green, isMainColorGreen ? 255 : 0); analogWrite(blue, isMainColorBlue ? 255 : 0);
Erweitern der Schaltung um einen Abstandssensor um die LEDs / den Sensor zu aktivieren
Wenn man etwas Stromsparen und ebenso auch den Sensor schonen möchte, dann kann man einen kleinen Abstandssensor in die Schaltung integrieren und so die LEDs und die Messung abhängig davon mach, ob sich ein Gegenstand vor dem Sensor befindet.
Für die Schaltung verwende ich einen Infrarotabstandssensor welcher einen digitalen und analogen Ausgang hat. Da mich lediglich interessiert, ob sich ein Gegenstand vor dem Sensor befindet, verwende ich den digitalen Ausgang, welchen man über einen Drehpotentiometer einstellen kann.
Im Code müssen wir recht wenig anpassen, denn der digitale Ausgang wird ähnlich einem Taster abgefragt und wir reagieren wenn dier LOW ist. Sollte der Ausgang HIGH sein so führen wir keine Messung durch und deaktivien ebenso die RGB LED (alle Farbwerte auf 0).
#define led 5
#define irSensor 7
void setup(void) {
...
pinMode(led, OUTPUT);
pinMode(irSensor, INPUT);
digitalWrite(led, HIGH);
...
}
void loop(void) {
if (digitalRead(irSensor) == HIGH) {
digitalWrite(led, LOW);
analogWrite(red, 0);
analogWrite(green, 0);
analogWrite(blue, 0);
return;
}
digitalWrite(led, HIGH);
...
}