Quelltext der Seite ESP8266 Wemos D1 Mini mit RGB-LED Beispiel

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

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

==Sketch digitale Ansteuerung==
Hier mein Sketch für den Test in welchen wir die einzelnen Farben nur an oder ausschalten.<br>
Der Sketch schaltet alle möglichen Farben im 3 Sekunden-Takt durch, die aktuelle Farbe wird über Seriell ausgegeben.<br><br>
<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>
<br>
----
==Testausgabe==
Nach dem Hochladen sollte im Seriellen Monitor so etwas stehen:<br>
 Setze Pins als Ausgänge
 Rot
 Grün
 Blau
 Pink
 Gelb
 Cyan
 Weiß
 Schwarz ;-)
<br>
----
==Sketch analoge Ansteuerung==
Scrollt weiter runter und nehmen den Sketch aus analoge Ansteuerung bei gemeinsamer Anode.<br>
Das funktioniert mit beiden Typen.<br>
<br>
----

='''Variante 2: Mit gemeinsamer Anode'''=
<br>
==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
<br>
----
==Schaltung==
Die RGB LED hat 4 Beine - und wenn man genau hinsieht sind alle unterschiedlich lang:<br>
:[[Datei:ClipCapIt-190305-225458.PNG]]<br>
Die Schaltung sieht so aus:<br>
[[Datei:Wemos_D1_Mini_+_RGB_LED_Anode_Steckplatine.png]]<br>
Die 3 Wiederstände haben 100 Ohm, je nach Modell und gewünschter Helligkeit muss der etwas größer oder kleiner sein.<br>
<br>
----

==Sketch digitale Ansteuerung==
Hier mein Sketch für den Test in welchen wir die einzelnen Farben nur an oder ausschalten.<br>
Der Sketch schaltet alle möglichen Farben im 3 Sekunden-Takt durch, die aktuelle Farbe wird über Seriell ausgegeben.<br>
<br>
Es ist das gleiche Programm wie bei der gemeinsamen Kathode - nur das nun <code>HIGH</code> und <code>LOW</code> vertauscht sind:<br>
<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>
<br>
----

==Testausgabe==
Nach dem Hochladen sollte im Seriellen Monitor so etwas stehen:<br>
 Setze Pins als Ausgänge
 Rot
 Grün
 Blau
 Pink
 Gelb
 Cyan
 Weiß
 Schwarz ;-)
<br>
----
==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.<br>
Der '''ESP8266''' und damit auch der '''Wemos D1 Mini''' können sogar 1024 Stufen, also Werte von 0 bis 1023 setzen.<br>
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.<br>
Das folgende Sketch sollte die RGB-LED so gut wie es geht in allen Farben hin und her wechseln lassen.<br>
<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>
<br>
----

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

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