BLinz: /* Sketch analoge Ansteuerung */

2019-03-06T20:55:46Z

Sketch analoge Ansteuerung

Neue Seite

In diesen Beispielen werden die 3 Farben der RGB-LED im ersten Beispiel digital angesteuert, also nur an- oder ausgeschaltet. 
Für den Zweck der Signalisierung reicht das, z.B. Grün = OK und Rot = Fehler. 
Die jeweilige Farbe der LED leuchtet dann jeweils in der vollen Helligkeit. 
 
Im jeweils 2. Beispiel verändern wir nichts an der Schaltung, steuern die Pins aber analog an. 
Hierdurch kann man die LEDs dimmen oder versuchen Farben zu mischen. 
----
=Arduiono Entwicklungsumgebung=
Ich nutze das Programm '''Arduino''' zur Programmierung. Zum Zeitpunkt der Erstellung dieses Artikels war das die Version 1.8.8 
Es wurde die ESP8266 Bibliothek eingebunden: 
Zuerst diese URL unter '''''Datei => Voreinstellungen''''' einbinden
:[[Datei:ClipCapIt-190228-205734.PNG]] 
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Und danach das Board (NICHT Bibliothek!) installieren unter '''''Werkzeuge => Board: "irgenetwas" => Boardverwalter''''' 
:[[Datei:ClipCapIt-190303-153010.PNG]] 
Hier nach <code>ESP8266</code> suchen udn den einzigen gefundenen Eintrag installieren: 
:[[Datei:ClipCapIt-190303-153145.PNG]]
 
Neben dem ES8266 Board brauchen wir keine weiteren Bibliotheken nachinstallieren, die notwendigen müssten schon ab Werk aktiv sein. 
Eine LED ansteuern ist so ziemlich das simpelste was die Adruinos machen können (oder der ESP8266). 
 
----
='''Variante 1: Mit gemeinsamer Kathode'''=
 
==Bauteile==
* 1 x Wemos D1 Mini
* 1 x RGB LED mit gemeinsamer Kathode - ich hab diese benutzt: https://www.amazon.de/gp/product/B01MSLOVIN
* 3 x Wiederstand 100 Ohm
 
----

==Schaltung==
Die RGB LED hat 4 Beine - und wenn man genau hinsieht sind alle unterschiedlich lang: 
:[[Datei:ClipCapIt-190305-223846.PNG]] 
Die Schaltung sieht so aus: 
[[Datei:Wemos_D1_Mini_+_RGB_LED_Kathode_Steckplatine.png]] 
Die 3 Wiederstände haben 100 Ohm, je nach Modell und gewünschter Helligkeit muss der etwas größer oder kleiner sein. 
Mit 220 Ohm sah ich direkt keinen großen unterschied bei der digitalen Ansteuerung. 
 
----

==Sketch digitale Ansteuerung==
Hier mein Sketch für den Test in welchen wir die einzelnen Farben nur an oder ausschalten. 
Der Sketch schaltet alle möglichen Farben im 3 Sekunden-Takt durch, die aktuelle Farbe wird über Seriell ausgegeben. 
<source lang="Java">
// Beispiel RGB LED mit gemeinsamer Kathode
// Die möglichen Pin-Nummern.
// D1 = 5 D2 = 4 D3 = 0 D4 = 2
// TX = 1 RX = 3 D0 = 16 D5 = 14
// D6 = 12 D7 = 13 D8 = 15
int PinRED = 5;
int PinGREEN = 4;
int PinBLUE = 0;

void setup() {
Serial.begin(115200);
delay(200);
// initialize digital pin LED_BUILTIN as an output.
Serial.println("Setze Pins als Ausgänge");
pinMode(PinRED, OUTPUT);
pinMode(PinGREEN, OUTPUT);
pinMode(PinBLUE, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
Serial.println("Rot");
digitalWrite(PinRED, HIGH); // HIGH = an, LOW = aus
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Grün");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Blau");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Pink");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Gelb");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Cyan");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Weiß");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Schwarz ;-)");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, LOW);
delay(3000);
}
</source>
 
----
==Testausgabe==
Nach dem Hochladen sollte im Seriellen Monitor so etwas stehen: 
Setze Pins als Ausgänge
Rot
Grün
Blau
Pink
Gelb
Cyan
Weiß
Schwarz ;-)
 
----
==Sketch analoge Ansteuerung==
Scrollt weiter runter und nehmen den Sketch aus analoge Ansteuerung bei gemeinsamer Anode. 
Das funktioniert mit beiden Typen. 
 
----

='''Variante 2: Mit gemeinsamer Anode'''=
 
==Bauteile==
* 1 x Wemos D1 Mini
* 1 x RGB LED mit gemeinsamer Anode - ich hab diese benutzt: https://www.amazon.de/gp/product/B071K9CV19
* 3 x Wiederstand 100 Ohm
 
----
==Schaltung==
Die RGB LED hat 4 Beine - und wenn man genau hinsieht sind alle unterschiedlich lang: 
:[[Datei:ClipCapIt-190305-225458.PNG]] 
Die Schaltung sieht so aus: 
[[Datei:Wemos_D1_Mini_+_RGB_LED_Anode_Steckplatine.png]] 
Die 3 Wiederstände haben 100 Ohm, je nach Modell und gewünschter Helligkeit muss der etwas größer oder kleiner sein. 
 
----

==Sketch digitale Ansteuerung==
Hier mein Sketch für den Test in welchen wir die einzelnen Farben nur an oder ausschalten. 
Der Sketch schaltet alle möglichen Farben im 3 Sekunden-Takt durch, die aktuelle Farbe wird über Seriell ausgegeben. 
 
Es ist das gleiche Programm wie bei der gemeinsamen Kathode - nur das nun <code>HIGH</code> und <code>LOW</code> vertauscht sind: 
<source lang="Java">
// Beispiel RGB LED mit gemeinsamer Anode
// Die möglichen Pin-Nummern.
// D1 = 5 D2 = 4 D3 = 0 D4 = 2
// TX = 1 RX = 3 D0 = 16 D5 = 14
// D6 = 12 D7 = 13 D8 = 15
int PinRED = 5;
int PinGREEN = 4;
int PinBLUE = 0;

void setup() {
Serial.begin(115200);
delay(200);
// initialize digital pin LED_BUILTIN as an output.
Serial.println("Setze Pins als Ausgänge");
pinMode(PinRED, OUTPUT);
pinMode(PinGREEN, OUTPUT);
pinMode(PinBLUE, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
Serial.println("Rot");
digitalWrite(PinRED, LOW); // LOW = an , HIGH = aus
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Grün");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Blau");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Pink");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Gelb");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, HIGH);
delay(3000);
Serial.println("Cyan");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Weiß");
digitalWrite(PinRED, LOW);
digitalWrite(PinGREEN, LOW);
digitalWrite(PinBLUE, LOW);
delay(3000);
Serial.println("Schwarz ;-)");
digitalWrite(PinRED, HIGH);
digitalWrite(PinGREEN, HIGH);
digitalWrite(PinBLUE, HIGH);
delay(3000);
}
</source>
 
----

==Testausgabe==
Nach dem Hochladen sollte im Seriellen Monitor so etwas stehen: 
Setze Pins als Ausgänge
Rot
Grün
Blau
Pink
Gelb
Cyan
Weiß
Schwarz ;-)
 
----
==Sketch analoge Ansteuerung==
Im Internet findet man Anleitungen für Adruino für das Dimmen von LED. Dabei werden die Ausgänge analog mit einem Wert zwischen 0 und 255 angesteuert. 
Der '''ESP8266''' und damit auch der '''Wemos D1 Mini''' können sogar 1024 Stufen, also Werte von 0 bis 1023 setzen. 
Erwartet aber nicht zuviel, der Bereich der RGB-LED ist begrenzter, erst ab einem bestimmten Schwellwert leuchtet die Farbe und und ab einen gewissen Punkt passiert nicht viel. 
Das folgende Sketch sollte die RGB-LED so gut wie es geht in allen Farben hin und her wechseln lassen. 
<source lang="Java">
// Beispiel RGB LED mit gemeinsamer Anode und analoger Ansteuerung - Dimmen!
// Die möglichen Pin-Nummern.
// D1 = 5 D2 = 4 D3 = 0 D4 = 2
// TX = 1 RX = 3 D0 = 16 D5 = 14
// D6 = 12 D7 = 13 D8 = 15
int PinRED = 5;
int PinGREEN = 4;
int PinBLUE = 0;

int ValueRED = random(1, 1024);
int ValueGREEN = random(1, 1024);
int ValueBLUE = random(1, 1024);

int addRED = 0;
int addGREEN = 0;
int addBLUE = 0;

void setup() {
Serial.begin(115200);
delay(200);
// initialize digital pin LED_BUILTIN as an output.
Serial.println("Setze Pins als Ausgänge");
pinMode(PinRED, OUTPUT);
pinMode(PinGREEN, OUTPUT);
pinMode(PinBLUE, OUTPUT);
Serial.println("Alle Farben aus.");
analogWrite(PinGREEN, 1024);
analogWrite(PinBLUE, 1024);
analogWrite(PinRED, 1024);
Serial.println("Zufallswerte + oder - setzen");
addRED = random (1,10);
Serial.print("Zufallswert Rot: ");
Serial.println(addRED);
addGREEN = random (1,10);
Serial.print("Zufallswert Grün: ");
Serial.println(addGREEN);
addBLUE = random (1,10);
Serial.print("Zufallswert Blau: ");
Serial.println(addBLUE);
Serial.print("Startwert Rot: ");
Serial.println(ValueRED);
Serial.print("Startwert Grün: ");
Serial.println(ValueGREEN);
Serial.print("Startwert Blau: ");
Serial.println(ValueBLUE);

}

// the loop function runs over and over again forever
void loop() {
// Rote LED
if (addRED < 6) {
//Serial.println("Rot plus);
ValueRED = ValueRED - 8;
if (ValueRED <= 1) {
ValueRED = 0;
addRED = 10;
}
} else {
//Serial.println("Rot Minus);
ValueRED = ValueRED + 8;
if (ValueRED >= 1023) {
ValueRED = 1023;
addRED = 1;
}
}
analogWrite(PinRED, ValueRED);

// Grüne LED
if (addGREEN < 6) {
ValueGREEN = ValueGREEN - 8;
if (ValueGREEN <= 1) {
ValueGREEN = 0;
addGREEN = 10;
}
} else {
ValueGREEN = ValueGREEN + 8;
if (ValueGREEN >= 1023) {
ValueGREEN = 1023;
addGREEN = 1;
}
}
analogWrite(PinGREEN, ValueGREEN);

// Blaue LED
if (addBLUE < 6) {
ValueBLUE = ValueBLUE - 8;
if (ValueBLUE <= 1) {
ValueBLUE = 0;
addBLUE = 10;
}
} else {
ValueBLUE = ValueBLUE + 8;
if (ValueBLUE >= 1023) {
ValueBLUE = 1023;
addBLUE = 1;
}
}
analogWrite(PinBLUE, ValueBLUE);

/*
Serial.print("Rot: ");
Serial.println(ValueRED);
Serial.print("Grün: ");
Serial.println(ValueGREEN);
Serial.print("Blau: ");
Serial.println(ValueBLUE);
*/
// Kurze Pause
delay(50);
}
</source>
 
----

==Testausgabe==
Na die RGB-LED sollte munter die Farben wechseln, im seriellen Monitor steht etwas zu den Startwerten. 
 
----

=Quellen=
Schaut euch das Beispiel "01. Basics => Blink" im Adruino-Editor an. 
----
=Kommentare=
<comments />

ESP8266 Wemos D1 Mini mit RGB-LED Beispiel - Versionsgeschichte

BLinz: /* Sketch analoge Ansteuerung */