Arduino UNO Q - TCS3200D/TCS230 Farbsensor
Der TCS3200D/TCS230-Farberkennungssensor erkennt Farben durch Messung der roten, grünen und blauen Lichtintensität. Er gibt ein frequenzbasiertes Signal aus, das Sie mit pulseIn() auslesen und nach der Kalibrierung auf Standard-0-255-RGB-Werte zuordnen.
In diesem Tutorial lernen Sie:
- Wie der TCS3200D/TCS230-Farbsensor funktioniert
- Wie man ihn an die Arduino UNO Q MCU anschließt
- Wie man das Kalibrierungs-Sketch ausführt, um genaue Messwerte zu erhalten
- Wie man RGB-Werte liest und dominante Farben erkennt
- Wie man Bridge verwendet, um Farbdaten auf die Linux-Seite (Python) freizugeben
- Wie man Telegram verwendet, um RGB-Werte und Farbnamen auf Arduino UNO Q abzufragen
- Wie man OpenClaw auf Arduino UNO Q mit dem Farbsensor verwendet
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über den TCS3200D/TCS230 Farbsensor
Der TCS3200D/TCS230 verwendet ein 8×8-Array von Photodioden: 16 rotgefiltert, 16 grüngefiltert, 16 blaugefiltert und 16 transparent. Er wandelt Lichtintensität in eine Rechteckwelle-Frequenz am OUT-Pin um. Durch Schalten von Filtern und Messen von Impulsbreiten erhalten Sie RGB-Werte.
Die meisten Module enthalten weiße LEDs zur Ausleuchtung des Zielobjekts, was konsistente Messwerte bei unterschiedlichem Umgebungslicht ermöglicht.
Pinbelegung
- VCC: 5V Stromversorgung
- GND: Masse
- S0, S1: Ausgangfrequenzskalierung — HIGH/LOW = 20% Skalierung (empfohlen)
- S2, S3: Farbfilterwahl
- OUT: Rechteckwelle-Frequenzausgang — mit pulseIn() messen
- OE: Ausgangaktivierung (aktiv LOW) — die meisten Module haben dies intern auf GND verdrahtet
Filterauswahl (S2, S3)
| S2 | S3 | Filter |
|-----|-----|---------|
| LOW | LOW | Rot |
| LOW | HIGH| Blau |
| HIGH| LOW | Transparent|
| HIGH| HIGH| Grün |
Impulsbreite → RGB
Niedrigere Impulsbreite = mehr Licht = höherer RGB-Wert. Nach der Kalibrierung:
rgb = map(pulseWidth, calibMin, calibMax, 255, 0);
Schaltplan
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
| TCS3200 Pin | Arduino UNO Q MCU |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | D4 |
| S1 | D3 |
| S2 | D6 |
| S3 | D5 |
| OUT | D7 |
Programmierung für TCS3200 Farbsensor
- Konfigurieren Sie alle Steuerpins als Ausgänge, OUT als Eingang, stellen Sie die Frequenzskalierung ein:
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
digitalWrite(S0, HIGH); // 20% scaling
digitalWrite(S1, LOW);
- Wählen Sie einen Filter und messen Sie die Impulsbreite:
// Red
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
int redPW = pulseIn(sensorOut, LOW);
// Green
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
int greenPW = pulseIn(sensorOut, LOW);
// Blue
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
int bluePW = pulseIn(sensorOut, LOW);
- Nach der Kalibrierung auf 0-255 abbilden (niedrigere PW = heller = höherer Wert):
int redValue = map(redPW, redMin, redMax, 255, 0);
Arduino UNO Q Code — Kalibrierung
Die TCS3200-Messwerte werden durch Entfernung, LED-Helligkeit und Umgebungslicht beeinflusst. Führen Sie zunächst dieses Kalibrierungs-Sketch aus, um die minimalen und maximalen Impulsbreiten für Ihr spezifisches Setup zu ermitteln.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// TCS3200 Color Sensor - Calibration Sketch
// Run this first to find the min/max pulse widths for your environment.
// Point the sensor at white, black, and various colored objects.
// Note the stable Min and Max values, then enter them into the main sketch.
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
int redPW = 0, greenPW = 0, bluePW = 0;
int redMin = 10000, redMax = 0;
int greenMin = 10000, greenMax = 0;
int blueMin = 10000, blueMax = 0;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Serial.begin(9600);
Serial.println("=== TCS3200 Calibration ===");
Serial.println("Point the sensor at different objects (white, black, colors).");
Serial.println("Min and Max values are tracked automatically.");
Serial.println("When values look stable, note them down for the main sketch.");
Serial.println("------------------------------------------");
}
void loop() {
redPW = getRedPW(); delay(200);
greenPW = getGreenPW(); delay(200);
bluePW = getBluePW(); delay(200);
if (redPW < redMin) redMin = redPW;
if (redPW > redMax) redMax = redPW;
if (greenPW < greenMin) greenMin = greenPW;
if (greenPW > greenMax) greenMax = greenPW;
if (bluePW < blueMin) blueMin = bluePW;
if (bluePW > blueMax) blueMax = bluePW;
Serial.print("Red PW = "); Serial.print(redPW);
Serial.print(" - Green PW = "); Serial.print(greenPW);
Serial.print(" - Blue PW = "); Serial.println(bluePW);
Serial.print(" Min -> R:"); Serial.print(redMin);
Serial.print(" G:"); Serial.print(greenMin);
Serial.print(" B:"); Serial.println(blueMin);
Serial.print(" Max -> R:"); Serial.print(redMax);
Serial.print(" G:"); Serial.print(greenMax);
Serial.print(" B:"); Serial.println(blueMax);
Serial.println("------------------------------------------");
}
Schnellschritte
Zum ersten Mal mit Arduino UNO Q? Folgen Sie zunächst dem Tutorial Getting Started with Arduino UNO Q.
- Anschließen: Verdrahten Sie den Farbsensor mit der Arduino UNO Q MCU wie im Schaltplan gezeigt.
- Öffnen Sie Arduino App Lab: Starten Sie Arduino App Lab und warten Sie, bis es Ihre Arduino UNO Q erkennt.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche Create New App.
- Geben Sie der App einen Namen, z.B.: ColorSensorCalibration
- Klicken Sie auf Create, um zu bestätigen.
- Fügen Sie das Sketch ein: Kopieren Sie den Kalibrierungscode oben und fügen Sie ihn in sketch/sketch.ino ein.
- Hochladen: Klicken Sie in Arduino App Lab auf die Schaltfläche Run.
- Bewegen Sie den Sensor über verschiedene Objekte: ein weißes Objekt, ein schwarzes Objekt und einige farbige Objekte.
- Beobachten Sie, wie die Min- und Max-Werte nach 10–20 Sekunden stabilisieren — notieren Sie sie sich.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:00] === TCS3200 Calibration ===
[2026-04-29 09:00:00] Point the sensor at different objects (white, black, colors).
[2026-04-29 09:00:00] Min and Max values are tracked automatically.
[2026-04-29 09:00:00] When values look stable, note them down for the main sketch.
[2026-04-29 09:00:00] ------------------------------------------
[2026-04-29 09:00:01] Red PW = 42 - Green PW = 55 - Blue PW = 60
[2026-04-29 09:00:01] Min -> R:42 G:55 B:60
[2026-04-29 09:00:01] Max -> R:42 G:55 B:60
[2026-04-29 09:00:01] ------------------------------------------
[2026-04-29 09:00:02] Red PW = 210 - Green PW = 185 - Blue PW = 172
[2026-04-29 09:00:02] Min -> R:42 G:55 B:60
[2026-04-29 09:00:02] Max -> R:210 G:185 B:172
[2026-04-29 09:00:02] ------------------------------------------
Aus der obigen Ausgabe sind Ihre Kalibrierungswerte:
- redMin = 42, redMax = 210
- greenMin = 55, greenMax = 185
- blueMin = 60, blueMax = 172
Arduino UNO Q Code — RGB-Werte auslesen
Aktualisieren Sie nun die sechs Kalibrierungsvariablen oben mit Ihren tatsächlichen Werten und laden Sie dieses Haupt-Sketch hoch, um genaue RGB-Werte auszulesen.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// TCS3200 Color Sensor - Read RGB Values
// IMPORTANT: Run the calibration sketch first and replace the 0 values below
// with your actual calibration numbers.
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
// Calibration values — replace with your values from the calibration sketch
int redMin = 0; // Red minimum pulse width
int redMax = 0; // Red maximum pulse width
int greenMin = 0; // Green minimum pulse width
int greenMax = 0; // Green maximum pulse width
int blueMin = 0; // Blue minimum pulse width
int blueMax = 0; // Blue maximum pulse width
int redPW = 0, greenPW = 0, bluePW = 0;
int redValue = 0, greenValue = 0, blueValue = 0;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Serial.begin(9600);
Serial.println("Arduino UNO Q TCS3200 Color Sensor ready");
}
void loop() {
redPW = getRedPW(); delay(200);
greenPW = getGreenPW(); delay(200);
bluePW = getBluePW(); delay(200);
// Map pulse width to 0-255 (lower PW = more light = higher value)
redValue = map(redPW, redMin, redMax, 255, 0);
greenValue = map(greenPW, greenMin, greenMax, 255, 0);
blueValue = map(bluePW, blueMin, blueMax, 255, 0);
Serial.print("Red = "); Serial.print(redValue);
Serial.print(" - Green = "); Serial.print(greenValue);
Serial.print(" - Blue = "); Serial.println(blueValue);
}
Schnellschritte
- Suchen Sie im obigen Code diese Zeilen:
int redMin = 0;
int redMax = 0;
int greenMin = 0;
int greenMax = 0;
int blueMin = 0;
int blueMax = 0;
- Ersetzen Sie alle sechs 0-Werte durch Ihre Kalibrierungsnummern. Zum Beispiel:
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
- Erstellen Sie eine neue App (oder aktualisieren Sie die vorherige), fügen Sie den Code ein und klicken Sie auf Run.
- Richten Sie den Sensor auf verschiedene farbige Objekte und beobachten Sie den Serial Monitor.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q TCS3200 Color Sensor ready
[2026-04-29 09:00:02] Red = 210 - Green = 35 - Blue = 20
[2026-04-29 09:00:03] Red = 25 - Green = 200 - Blue = 40
[2026-04-29 09:00:04] Red = 30 - Green = 45 - Blue = 215
[2026-04-29 09:00:05] Red = 225 - Green = 220 - Blue = 218
Bridge: Linux + MCU
Dieser Abschnitt zeigt, wie beide Prozessoren der Arduino UNO Q zusammenarbeiten, damit die Linux-Seite kontinuierlich Farbdaten über Bridge auslesen kann:
- Der Farbsensor ist mit der MCU verbunden — die MCU liest alle 600 ms RGB-Werte aus und speichert sie zwischen
- Die MPU kann den Sensor nicht direkt auslesen — sie ruft Bridge-Funktionen auf, um RGB oder Farbnamen zu erhalten
- Die MPU hat Wi-Fi — bei vollständiger Debian Linux-Ausführung kann sie auf Telegram-Befehle mit Live-Farbmessungen reagieren
- Arduino_RouterBridge ermöglicht RPC-Kommunikation zwischen den beiden Prozessoren
- ⚠️ /dev/ttyHS1 (Linux) und Serial1 (MCU) sind RESERVIERT vom Router — öffnen Sie diese niemals in Benutzercode
Die MCU-Schleife liest die R-, G-, B-Kanäle alle 600 ms aus und speichert die Werte. Bridge-Callbacks stellen die zwischengespeicherten Werte sofort zur Verfügung, ohne zu blockieren.
MCU Code (Bridge)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
#include "Arduino_RouterBridge.h"
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
// Calibration values — replace with your values from the calibration sketch
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
// Cached RGB values
int cached_red = 0;
int cached_green = 0;
int cached_blue = 0;
unsigned long last_read_ms = 0;
const unsigned long READ_INTERVAL = 600;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
String get_rgb(String arg) {
return "R:" + String(cached_red) + " G:" + String(cached_green) + " B:" + String(cached_blue);
}
String get_color(String arg) {
int r = cached_red;
int g = cached_green;
int b = cached_blue;
// Detect dominant color
if (r > 200 && g > 200 && b > 200) return "white";
if (r < 50 && g < 50 && b < 50) return "black";
if (r > g && r > b) return "red";
if (g > r && g > b) return "green";
if (b > r && b > g) return "blue";
return "unknown";
}
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Bridge.provide("get_rgb", get_rgb);
Bridge.provide("get_color", get_color);
Monitor.println("Arduino UNO Q TCS3200 Color Sensor Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= READ_INTERVAL) {
last_read_ms = now;
int redPW = getRedPW(); delay(200);
int greenPW = getGreenPW(); delay(200);
int bluePW = getBluePW(); delay(200);
cached_red = constrain(map(redPW, redMin, redMax, 255, 0), 0, 255);
cached_green = constrain(map(greenPW, greenMin, greenMax, 255, 0), 0, 255);
cached_blue = constrain(map(bluePW, blueMin, blueMax, 255, 0), 0, 255);
}
}
Python Code (Bridge)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
from arduino.app_utils import *
import time
def loop():
rgb = Bridge.call("get_rgb")
color = Bridge.call("get_color")
print(f"Color: {color} | {rgb}")
time.sleep(1)
App.run(user_loop=loop)
Schnellschritte
- Anschließen: Verdrahten Sie den Farbsensor mit der Arduino UNO Q wie im Schaltplan gezeigt.
- Öffnen Sie Arduino App Lab und erstellen Sie eine neue App namens ColorSensorBridge.
- Aktualisieren Sie Kalibrierungswerte im MCU Bridge-Code (redMin, redMax, usw.) mit Ihren Werten aus dem Kalibrierungs-Sketch.
- Fügen Sie das MCU-Sketch in sketch/sketch.ino ein.
- Fügen Sie den Python-Code in die Python-Datei ein.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Hochladen: Klicken Sie auf die Schaltfläche Run.
- Richten Sie den Sensor auf verschiedene farbige Objekte — beobachten Sie, wie sich die Python-Konsole jede Sekunde aktualisiert.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q TCS3200 Color Sensor Bridge ready
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] Color: red | R:215 G:30 B:25
[2026-04-29 09:00:03] Color: green | R:28 G:205 B:38
[2026-04-29 09:00:04] Color: blue | R:22 G:40 B:218
[2026-04-29 09:00:05] Color: white | R:228 G:222 B:220
[2026-04-29 09:00:06] Color: black | R:12 G:10 B:8
Telegram
Fragen Sie den Farbsensor über Telegram-Befehle aus der Ferne auf Arduino UNO Q ab.
MCU-Sketch: Behalten Sie das gleiche MCU-Sketch aus dem vorherigen Bridge-Abschnitt bei.
Python Code (Telegram)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
from arduino.app_utils import *
import requests
import time
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
CHAT_ID = "YOUR_CHAT_ID"
last_update_id = 0
def get_updates():
global last_update_id
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates"
params = {"offset": last_update_id + 1, "timeout": 5}
try:
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["ok"]:
return data["result"]
except Exception as e:
print(f"Error getting updates: {e}")
return []
def send_message(chat_id, text):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {"chat_id": chat_id, "text": text}
try:
requests.post(url, data=payload, timeout=10)
except Exception as e:
print(f"Error sending message: {e}")
def loop():
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
if "message" not in update:
continue
message = update["message"]
chat_id = message["chat"]["id"]
text = message.get("text", "").strip()
print(f"Received: {text}")
if text == "/start":
send_message(chat_id,
"Arduino UNO Q Color Sensor Bot\n"
"/rgb - Read RGB values (0-255)\n"
"/color - Detect dominant color")
elif text == "/rgb":
result = Bridge.call("get_rgb")
send_message(chat_id, f"RGB values: {result}")
elif text == "/color":
result = Bridge.call("get_color")
send_message(chat_id, f"Detected color: {result}")
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(0.5)
App.run(user_loop=loop)
Schnellschritte
- Ersetzen Sie YOUR_TELEGRAM_BOT_TOKEN durch Ihren tatsächlichen Telegram-Bot-Token von BotFather.
- Ersetzen Sie YOUR_CHAT_ID durch Ihre Telegram-Chat-ID.
- Fügen Sie diesen Python-Code in die Python-Datei Ihrer App ein (behalten Sie das gleiche MCU-Sketch bei).
- Klicken Sie auf die Schaltfläche Run und testen Sie mit den Befehlen /rgb und /color.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:00] Waiting for Telegram messages...
[2026-04-29 09:10:03] Received: /rgb
[2026-04-29 09:10:06] Received: /color
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw
You can adapt the OpenClaw to this tutorial by refering the instruction on Arduino Uno Q - OpenClaw Tutorial
Projektideen
Sie können viele nützliche Projekte mit dem TCS3200-Farbsensor und Arduino UNO Q erstellen:
- Farbsortiermaschine: Erkennen Sie die Farbe von Objekten auf einem Förderband über Bridge — lassen Sie die MCU ein Servo auslösen, um jedes Objekt auf der Grundlage seiner erkannten Farbe zum richtigen Behälter umzuleiten
- Remote-Farbprotokollierung: Protokollieren Sie erkannte Farben und RGB-Werte alle 5 Sekunden in eine CSV-Datei unter Linux — verwenden Sie einen Telegram-Befehl /report, um die letzten 10 Messwerte mit Zeitstempel zu erhalten
- Farbaktivierte Warnung: Verwenden Sie Telegram, um eine Zielfarbe zu definieren — wenn der Sensor diese genaue Farbe erkennt, senden Sie sofort eine Telegram-Benachrichtigung (z.B. zur Qualitätskontrolle in einer Produktionslinie)
- Überwachung der Pflanzengesundheit: Richten Sie den Sensor auf Pflanzenblätter — verfolgen Sie täglich den Grünkanal-Wert, um frühes Vergilben oder Verfärbungen zu erkennen, und senden Sie eine Telegram-Warnung, wenn der Grünwert unter einen Schwellenwert fällt
- Interaktives Farbspiel: Senden Sie eine Telegram-Nachricht wie „Zeige mir BLAU in 10 Sekunden" — die MCU liest die Farbe und Python antwortet, ob der Spieler die richtige Farbe vor Ablauf der Zeit gezeigt hat
Fordern Sie sich selbst heraus
Bereit, mit dem TCS3200-Farbsensor auf Arduino UNO Q weiterzugehen? Probieren Sie diese Herausforderungen:
- Leicht: Fügen Sie einen /history-Telegram-Befehl hinzu, der die letzten 5 erkannten Farben mit Zeitstempeln in einer Python-Liste speichert — nützlich zum Überprüfen der letzten Messwerte ohne die Konsole zu überprüfen.
- Mittel: Implementieren Sie Mittelwertbildung: Anstatt einen einzelnen Messwert zwischenzuspeichern, lesen Sie jede R/G/B-Kanal 3-mal durch und geben Sie den Durchschnitt zurück — dies glättet Rauschen und verbessert die Farberkennung.
- Fortgeschritten: Erstellen Sie ein Farblernsystem: Fügen Sie /learn red, /learn green, /learn blue-Telegram-Befehle hinzu, die die aktuelle RGB-Messung erfassen und als Referenz für diese Farbe speichern — verwenden Sie dann diese gespeicherten Referenzen zum Farbabgleich anstelle von hartcodierten Schwellenwerten.