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

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Und danach das Board (NICHT Bibliothek!) installieren unter Werkzeuge => Board: "irgenetwas" => Boardverwalter

Hier nach ESP8266 suchen udn den einzigen gefundenen Eintrag installieren:

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:

Die Schaltung sieht so aus:

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.

// 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);
}

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:

Die Schaltung sieht so aus:

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 HIGH und LOW vertauscht sind:

// 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);
}

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.

// 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);
}

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

Loading comments...

ESP8266 Wemos D1 Mini mit RGB-LED Beispiel

Aus znilwiki

Inhaltsverzeichnis

Arduiono Entwicklungsumgebung

Variante 1: Mit gemeinsamer Kathode

Bauteile

Schaltung

Sketch digitale Ansteuerung

Testausgabe

Sketch analoge Ansteuerung

Variante 2: Mit gemeinsamer Anode

Bauteile

Schaltung

Sketch digitale Ansteuerung

Testausgabe

Sketch analoge Ansteuerung

Testausgabe

Quellen

Kommentare