Zum Hauptinhalt springen

💥 Beacon-Licht

💎 Ziel​

  • Den Beacon verstehen
  • Die Farben einzeln ansteuern können
  • Einen Regenbogen Effekt erzeugen

⭐ Aufgabe Ein- und Ausschalten​

1. Pin-Nummern festlegen​

Im Allgemeinen ist das vorgehen identisch zu den LEDs, der Unterschied hierbei ist das die Beacon LED eine RGB ist. Das heißt sie kann Rot, Grün und Blau leuchten. Also muss nun zuerst jede Farbe der LED dem dazugehöhrenden Pin zugewiesen werden. Hierbei ist es Wichtig zu wissen das die LED insgesamt mit 4 Pins verbunden ist 3 davon für die genannten farben und der letzte für den eingang des Stroms der LED, dieser ist jedeglich wichtig für die Hardware.

const int signalLedRot   = 3;   
const int signalLedGruen = 5;   
const int signalLedBlau  = 6;

Hier haben wir jetzt also dem Pin 3 für Rot, Pin 5 für Grün und 6 für Blau. Pin 4 ist hier also der Eingang der LED welcher nicht benutz wird.

2. Pins als Ausgänge festlegen​

Auch hier ändert sich zum Kapitel LED jedeglich die anzahl der festzulegenen LED zustaände

void setup() {
  pinMode(signalLedRot, OUTPUT);
  pinMode(signalLedGruen, OUTPUT);
  pinMode(signalLedBlau, OUTPUT);
}

3. LEDs einschalten​

Hier lässt sich wunderbar entdecken, was die LED alles kann: Durch das gezielte Ausschalten oder Dimmen einzelner Farben lässt sich jeder gewünschte Ton erzeugen.

Um ein Gefühl für die Farbmischung zu bekommen, bietet es sich an, gezielt Mischfarben wie Orange oder Lila einzustellen.

Besonders spannend ist es auch zu beobachten, was passiert, wenn alle Farben gleichzeitig leuchten. Probiert hier gerne verschiedene Kombinationen aus, um ein gutes Gespür für den Beacon zu entwickeln!

void loop() {
  analogWrite(sinalLedRot, 255);          
  analogWrite(signalLedGruen, 255);  
  analogWrite(signalLedBlau, 255);     
}

✨ Regenbogeneffekt​

1. Variablen für den Zeitverlauf festlegen​

Um einen flüssigen Farbwechsel ohne ruckartige Sprünge zu erzeugen, wird mit Zeitstempeln gearbeitet. Das Programm merkt sich den letzten Zeitpunkt der Farbänderung und zählt den Farbwert schrittweise auf dem Farbkreis (0 bis 359 Grad) nach oben. Diese Variablen gehören ganz nach oben in das Programm, noch vor die Funktionen. Nicht vergessen sollte ein neues programm gestartet werden, dass die Pins und der output nochmals festgelegt werden müssen.

unsigned long letzterRegenbogenZeitpunkt = 0;  // Zeitstempel des letzten Farbwechsels
uint16_t farbton = 0;                          // Aktueller Wert auf dem Farbkreis (0-359)

2. Die Farbumrechnung (HSV zu RGB)​

Da Mikrocontroller standardmäßig nur mit Rot-, Grün- und Blauwerten (RGB) arbeiten, fällt die direkte Programmierung eines Regenbogens schwer. Leichter gelingt dies über das HSV-Modell, welches auf einem Farbkreis basiert. Eine Hilfsfunktion übernimmt hierbei die mathematische Umrechnung des Farbtons in die passenden Signale für die LED-Pins.

// Wandelt eine Farbe aus dem HSV-Modell (Farbton, Sättigung, Helligkeit)
// in RGB-Werte um, die direkt an die LED-Pins geschrieben werden können
static void hsvNachRgb(uint16_t farbtonWert, uint8_t saettigung, uint8_t helligkeit,
                        uint8_t &rot, uint8_t &gruen, uint8_t &blau) {
  if (saettigung == 0) { rot = gruen = blau = helligkeit; return; }

  uint16_t bereich = farbtonWert / 60;              // Farbkreis in 6 Sektoren aufgeteilt
  uint16_t rest    = (farbtonWert % 60) * 255 / 60; // Position innerhalb des Sektors

  uint8_t p = (uint16_t)helligkeit * (255 - saettigung) / 255;
  uint8_t q = (uint16_t)helligkeit * (255 - ((uint16_t)saettigung * rest) / 255) / 255;
  uint8_t t = (uint16_t)helligkeit * (255 - ((uint16_t)saettigung * (255 - rest)) / 255) / 255;

  switch (bereich) {
    case 0: rot = helligkeit; gruen = t; blau = p; break;
    case 1: rot = q; gruen = helligkeit; blau = p; break;
    case 2: rot = p; gruen = helligkeit; blau = t; break;
    case 3: rot = p; gruen = q; blau = helligkeit; break;
    case 4: rot = t; gruen = p; blau = helligkeit; break;
    default: rot = helligkeit; gruen = p; blau = q; break; // Sektor 5
  }
}

3. Den Regenbogen-Effekt steuern​

Hier lässt sich nun die eigentliche Magie des Farbverlaufs beobachten. Die Funktion sorgt dafür, dass sich der Farbton im Hintergrund immer weiterdreht. Über den Parameter der Geschwindigkeit lässt sich flexibel einstellen (nächster Schritt), wie schnell oder langsam die Farben ineinander übergehen sollen.

void signalLeuchteRegenbogen(uint8_t regenbogenGeschwindigkeit) {
  unsigned long aktuellerZeitpunkt = millis();  // Aktuelle Zeit in Millisekunden

  // Nur weitermachen, wenn genug Zeit seit dem letzten Schritt vergangen ist
  if (aktuellerZeitpunkt - letzterRegenbogenZeitpunkt < regenbogenGeschwindigkeit) return;
  letzterRegenbogenZeitpunkt = aktuellerZeitpunkt;

  // Farbton um einen Schritt weiterdrehen, nach 360° wieder von vorne beginnen
  farbton++;
  if (farbton >= 360) farbton = 0;

  // Farbton in RGB-Werte umrechnen (volle Sättigung und Helligkeit)
  uint8_t r, g, b;
  hsvNachRgb(farbton, 255, 255, r, g, b);

  // Die berechneten Werte an die drei RGB-Pins übergeben
  analogWrite(signalLedRot, r);
  analogWrite(signalLedGruen, g);
  analogWrite(signalLedBlau, b);
}

4. Aufruf im Hauptprogramm​

Damit der Effekt dauerhaft sichtbar bleibt, wird die neue Funktion einfach in die unendliche Hauptschleife eingebunden. Als Wert in den Klammern wird die gewünschte Wartezeit in Millisekunden übergeben – ein kleinerer Wert sorgt für ein schnelleres Farbspektakel.

void loop() {
  // Lässt den Regenbogen mit 15 Millisekunden Pause pro Schritt laufen
  signalLeuchteRegenbogen(15); 
}