Das Licht leuchtet hier in verschiedenen Farben. Mit Hilfe des TCS3200 Sensor, können die verschiedenen Farben gemessen werden. Anders als bei einem lichtempfindlichen Sensor, an dem sich der Leitwert verändert, liegt ein Pulssignal an. Für die Schaltung werden insgesamt fünf Digitale Ports und zwei Pins für die Spannungsversorgung benötigt.
Wenn mal kein Breadboard zur verfügung steht, geht das auch so wie im folgendem Bild. Die Pins von S0 bis S3 und OUT auf die digitalen Ausgängen von Pin 2 bis Pin 6 steckt.
Wie die Schaltung bereits verrät, ist das einlesen deutlich anders. Anstatt über OneWire , I²C oder eines Spannungspegel, kommt ein PWM (oder auch PPM) Signal. Je nach Farbe müssen die Anschlüsse von S0 bis S3 entsprechend geschaltet sein. Das bedeutet wiederum, dass die Farben nacheinander gemessen werden. Im .NET Micro Framework gibt es zum Einlesen die Klasse "InteruptPort", mit der auf das PWM Signal reagiert werden kann. Das erfordert etwas zusätzlichen Programmcode.
| // Optionen für Ausgangsfrequenz
public enum OutputFrequencyScaling
{
PowerDown,
TwoPercent,
TwentyPercent,
HundredPercent
} // Filter Auswahl
public enum SelectColor
{
Red,
Blue,
Green,
Clear
} public class Program
{
// Die Klasse wird für das Einlesen des PWM Signals verwendet.
private static InterruptPort _IntPort = new InterruptPort(
Pins.GPIO_PIN_D6,
true,
Port.ResistorMode.Disabled,
Port.InterruptMode.InterruptEdgeBoth); // Ruft die gemessene Zeit ab,
// wann die HIGH Pegele begonnen hat oder legt diese fest.
private static long _HighTicks = 0; // S0 und S1 Schaltet die Ausgangs frequenz entsprechend ein (Siehe dazu Datasheet)
private static OutputPort _S0 = new OutputPort(Pins.GPIO_PIN_D2, false);
private static OutputPort _S1 = new OutputPort(Pins.GPIO_PIN_D3, false); // S2 und S3 Schaltet die verschiedenen Filter Möglichkeiten ein
private static OutputPort _S2 = new OutputPort(Pins.GPIO_PIN_D4, false);
private static OutputPort _S3 = new OutputPort(Pins.GPIO_PIN_D5, false); // Die Onboard LED als Status Aktivität
private static OutputPort _StatusLED = new OutputPort(Pins.ONBOARD_LED, false); private static string _readColorName = string.Empty; private static bool _valueIsSet = false;
private static long _resultTemp = 0;
private static int _resultRed = 0;
private static int _resultBlue = 0;
private static int _resultGreen = 0;
private static int _resultClear = 0; public static void Main()
{
OutputFrequencyScaling scale = OutputFrequencyScaling.TwoPercent; while (true)
{
// Status Lesen
_StatusLED.Write(true); // Farben nach einander einlesen.
ReadPwmSignal(ref _resultRed, SelectColor.Red, scale);
ReadPwmSignal(ref _resultBlue, SelectColor.Blue, scale);
ReadPwmSignal(ref _resultGreen, SelectColor.Green, scale);
ReadPwmSignal(ref _resultClear, SelectColor.Clear, scale); // Ausgabe über die Messergebnisse.
Debug.Print("Red:" + _resultRed.ToString() +
"\t Blue:" + _resultBlue.ToString() +
"\t Green:" + _resultGreen.ToString() +
"\t Clear:" + _resultClear.ToString()); // Status warten
_StatusLED.Write(false);
Thread.Sleep(500);
}
} // Methode mit Filter- und Ausgangsfrequenzschalten und gibt das Ergebnis über "result" zurück.
private static void ReadPwmSignal(ref int result, SelectColor color, OutputFrequencyScaling scaling)
{
// Ausgangsfrequenz schalten
switch (scaling)
{
case (OutputFrequencyScaling.TwoPercent): { _S0.Write(false); _S1.Write(true); break; }
case (OutputFrequencyScaling.TwentyPercent): { _S0.Write(true); _S1.Write(false); break; }
case (OutputFrequencyScaling.HundredPercent): { _S0.Write(true); _S1.Write(true); break; }
default: { _S0.Write(false); _S1.Write(false); break; }
} // Filter einstellen
switch (color)
{
case (SelectColor.Red): { _S2.Write(false); _S3.Write(false); break; }
case (SelectColor.Blue): { _S2.Write(false); _S3.Write(true); break; }
case (SelectColor.Green): { _S2.Write(true); _S3.Write(true); break; }
default: { _S2.Write(true); _S3.Write(false); break; }
} // Member für das erfassen des Messergebnisses.
_HighTicks = 0;
_resultTemp = 0;
_valueIsSet = false; // Event zuweisen
_IntPort.OnInterrupt += _IntPort_OnInterrupt; // Warten
for (int i = 0; i < 5; i++) { Thread.Sleep(2); } // Event wieder abziehen
_IntPort.OnInterrupt -= _IntPort_OnInterrupt;
// Ergebniss kopieren
result = (int)_resultTemp;
} // Wird ausgeführt, wenn sich der Pegel am Digitalen Port geändert hat.
private static void _IntPort_OnInterrupt(uint data1, uint data2, DateTime time)
{
// Lock verhindert, das ein zweiter unmittelbarer Event nicht erfolgen kann.
lock (_IntPort)
{
// Wenn noch kein Wert erfasst wurde.
if (!_valueIsSet)
{
// Wenn HIGH Pegel anlieg und die Aktuelle
// Zeit in Ticks noch nicht erfast wurde.
if (data2 == 1 & _HighTicks == 0)
{
// Aktuelle Zeit in Ticks zwischen speichern
_HighTicks = time.Ticks;
}
else if (_HighTicks != 0 & !_valueIsSet)
{
// Wenn der Pegel von HIGH nach LOW gewechselt hat
_resultTemp = time.Ticks - _HighTicks;
// True zuweisen, dass der Messwert erfasst wurde
_valueIsSet = true;
// Event abziehen
_IntPort.OnInterrupt -= _IntPort_OnInterrupt;
}
}
}
}
} |
Als Ausgangsergebnis werden vier Werte wiedergegeben. Wenn nun vor dem Sensor eine Farbige Fläche mit einer der Grundfarben gehalten wird, dann verändern sich die Werte dementsprechend. Stammt die Farbe von einem Bildschirm (wie im folgenden Bild von einem Smart Phone), dann kann der Blaue Jumper herausgezogen werden, um die LED Beleuchtung abzustellen.
Bei grob angemalten Flächen wie dieser Karteikarte funktioniert es weniger gut..
Anhand der Farbe stellen sich die Werte neu ein. Je ein deutiger die Farbe ist, um so deutlicher zeigt sich das Ergebnis.
Also bei durch gehenhenden Blau, Grün oder Rot zeigt sich ein hoher Wert. Wenn die Farbfläche jedoch wie bei meinem Beispiel mit der Karteikarte durchgeführt wird, stehen an jeden Ausgang relativ hohe Werte.
Noch ein Hinweis. Die Pulslänge wird kürzer, wenn der Weg des reflecktierten Licht kürzer wird, oder salobt gesagt, wenn die Farbfläche zu nah am Sensor ist, dann ist das Pulssignal sehr kurz. Dies führt dann dazu, dass die letzte Methode sehr häufig ausgeführt wird. Im schlimmsten Fall kommt es zu einem Speicherüberlauf und das Programm bleibt stehen.
Beispiel Programm zum Herunterladen für Netduino mit .NET Micro Framework 4.2
