Hallo
Ich hatte ja vor zirka einem Jahr schon einmal ein Projekt vorgestellt in dem es um die Simulation des geflimmer von Fernsehern auf der
Modellbahn ging. Hier mal der Link in das damalige Thema viewtopic.php?f=7&t=143869&hilit=Fernsehsimulation
Die dort verwendete Vorgehensweise hat ein paar kleine Nachteile, so müssen pro (Farb)Fernsehprogramm drei PWM-Anschlüsse eines
Arduino verwendet werden. Dazu kommt das man, sollte man mehrere LED auf dem selben Kanal betreiben wollen, man eine Treiberstufe
dazu schalten muss.
Nun ist mir vor einiger Zeit ein sogenannter NEOPixel-Streifen in die Hände gefallen.
Dieses Ding besteht in meinem Fall aus acht RGB-LED die einen eingebauten Chip haben, über den man sie steuern kann.
Der Vorteil ist, sie brauchen nur die Versorgungsspannung und ein Signal am Steuereingang(genannt Di) um angesteuert zu werden.
Will man mehrere dieser LED betreiben, muss man nur die erste LED mit dem Anschluss Di an den Arduino anschließen und die zweite LED
mit dem Eingang Di an den Ausgang DO der ersten LED . Für alle weiteren LED gilt das gleiche Prinzip, es werden Di der nächsten mit
DO der vorhergehenden LED verbunden. Beachten sollte man, das diese LED(auch die Streifen) meist mit 5V versorgt werden.
Diese LED bekommt man sowohl einzeln als WS2812 sowie als LED-Strip, als auch schon verbaut auf diversen Modulen für den Arduino.
Da diese LED mindestens 5 x 5mm groß sind und mir das für meine "Fernseher" zu groß ist, werde ich wohl, zumindest teilweise,
darauf zurück greifen kleine SMD-RGB-LED an einen WS2801 zu löten. Dieser WS2801 ist eben jener Chip der in den fertigen WS2812 LED
verbaut ist.(zumindest vom Funktionsprinzip)
Wozu nun das ganze?
Ich wollte eine einfachere Möglichkeit erreichen, mehrere Modellhäuschen bzw. Wohnungen mit dem selben geflimmer zu versorgen.
Das ganze hat sich mit diesen LED doch als problematischer erwiesen als anfangs gedacht.
Aber nun bin ich, glaube ich zumindest, zu einem relativ gutem Ergebnis gekommen.
Als erstes stelle ich mal den Sketch hier ein.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
// Versuch einer Fernsehsimulation mit NEOPixel
// einbinden der verwendeten Bibliothek
#include <Adafruit_NeoPixel.h>
// Pin festlegen der die Daten an die NEOPixel übergibt
#define PIN 8
// festlegen der Variablen für die Farben
byte r,g,b;
// festlegen der Variablen für die Pixelnummer, Anzahl muss mit der Anzahl der verwendeten
// NEOPixel(LED) übereinstimmen
byte led[] = {0, 1, 2, 3, 4, 5, 6, 7}; // es wird immer bei Null zu zählen begonnen
// Zufallszahl übernehmen
long randNumber;
// Einstellungen, (Anzahl der LED, Pin, Art der LED)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(8, PIN, NEO_GRB + NEO_KHZ800);
// leuchtdauer der LED festlegen in Millisekunden
long ledtakt[] = {18000, 18000, 18000, 18000, 18000, 18000, 18000, 18000};
long ledtakt2[] = {48000, 52000, 42000, 33000, 64000, 74000, 56000, 36000};
// merken der Schaltzeiten
long ledtime[sizeof(led)];
long ledtime2[sizeof(led)];
void setup() {
strip.begin(); // startet den LED-Strip
strip.clear(); // schaltet alle LED im Strip dunkel
strip.show(); // schreibt die aktuellen Daten in die LED
}
// berechnen der verwendeten Zeiten
boolean milliSekundenTakt(long dauer, long &alterWert){
if (millis() - alterWert < dauer) return false;
while (millis() - alterWert >= dauer) alterWert+=dauer;
return true;
}
// LED Ablaufplan Zeit
void Ablaufplan() {
// Ablaufplan für LED einschalten
for (long i=0;i<sizeof(led);i++)
if (milliSekundenTakt(ledtakt[i],ledtime[i]))
{
strip.setPixelColor(led[i], r, g, b); // LED einschalten
}
// Ablaufplan für die LED auschalten
for (long i=sizeof(led);i>0;i--) // LED in Schleife durchgehen
{
if (milliSekundenTakt(ledtakt2[i],ledtime2[i])) // Zeit für diese LED abgelaufen?
{
strip.setPixelColor(led[i], 0, 0, 0); // LED ausschalten
}
}
}
void loop() {
g = random(70, 210); // diese Einstellung erzeugt weitgehend
r = random(0, 85); // ein weißes Licht mit blau und grün Stich
b = random(60, 150); // rot tritt eher selten auf
strip.setBrightness(random(40,65)); // sorgt für das schwanken der Helligkeit
randNumber = random(500,2500); // zu kleine Werte lassen die LED in unterschiedlchen
delay(randNumber); // Farben zu einander leuchten.
// im Extremfall blitzen die LED auch
strip.show();
Ablaufplan();
}
Ich habe einige Kommentare im Sketch eingefügt, so das man hoffentlich erkennen kann was erreicht werden sollte.
Bei diesem Sketch handelt es sich also erstmal nur um einen "Kanal" und er belegt einen Pin an einem Arduino.
Dieser Pin muss auch kein PWM unterstützen.
Was passiert also wenn das Programm läuft?
Es werden nach einer (eingestellten) Zeit die LED eingeschalten.
Sie schwanken dann in ihrer Helligkeit und Farbnuance. Der Grundton ist eher ein Weiß, das zufällig auch bläulich oder grünlich schimmert.
Diese Farbnuancen kann man natürlich im Programm nach eigenem Gusto anpassen.
Nach einer festgelegten Zeit(für jede LED einzeln) schalten sie sich aus und dann auch wieder ein.
Und da liegt das Problem --- es hat sehr lange gedauert bis ich es hinbekommen habe, das die LED die sich dazu schaltet, die selbe Farbe hat,
wie jene die bereits leuchten.
Dies ist übrigens auch der Grund warum alle LED zur selben Zeit das erste Mal eingeschalten werden.
Legt man dort für jede LED eine eigene "Startzeit" fest, weichen die Farben voneinander ab.
Noch bin ich mir nicht sicher ob das ganze auch noch so funktioniert wenn ich noch mehr LED an einem "Kanal" betreibe.
Oder ob man dann wieder andere Einstellungen im Programm machen muss.
Aber mit diesen acht LED die ich jetzt betreibe kommt es nahe an mein Wunschergebnis heran.
Sollte es Fragen oder Anregungen zu dem ganzen geben, ich bin ganz Ohr.
Gruß Bernd
- bekunden, dass ich beeindruckt bin. Das eröffnet interessante Möglichkeiten. Danke, dass Du das mit uns teilst.
