Dauerkalender

Lagerfeuer mit Arduino

In dem folgenden Versuch kommen neben einem Arduino Nano und drei Schieberegistern 74HC595 24 Leuchtdioden zum Einsatz. Mit den Leuchtdioden soll eine Lagerfeuer-Flamme imitiert werden. Die Leuchtdioden werden auf drei Achtergruppen unterteilt. Jede Gruppe bildet eine Teilflamme, die unabhängig von den anderen agiert. In dem Versuch wird lediglich eine Bewegungsform einer echten Flamme nachgebildet. Die Leuchtdioden, die senkrecht übereinander angeordnet sind, werden nacheinander, beginnend mit der untersten Leuchtdiode zugeschaltet, bis sie eine via Zufall bestimmte maximale Höhe erreichen. Anschließend werden sie nach und nach wieder abgeschaltet. Die Zeitspanne zwischen der Ein- und Abschaltung der einzelnen Leuchtdioden wird ebenfalls via Zufall bestimmt.
Mit dieser Methode fällt die Imitation einer Flamme schon ganz gut aus.
Bei Bedarf, was allerdings mit einem höheren Programmierungsaufwand verbunden wäre, können auch andere Flamme Verhaltensweise nachgebildet werden. Dazu würde z.B. Bewegung einer Gruppe von Leuchtionen nach oben mit anschließender Abschaltung gehören. Mit einem PWM-Verfahren könnte man den abgebildeten Flammen unterschiedliche Helligkeiten zuordnen. Schließlich würden mit Sicherheit gelegentlich abspringende einzelne Funken eine LED-Imitation dem echten Lagerfeuer ganz nah bringen.

Mikrocontroller

Wie bereits erwähnt basiert die Bildung der einzelnen drei Flammen auf Zufallszahlen. Für jeden Durchgang wird zunächst die Anzahl der teilnehmenden Leuchtdioden bestimmt. Maximal besteht eine Teilflamme aus acht Leuchtdioden. Die Zahl der Leuchtdioden wird in der Variable Flamme [x][1] (x steht für Nummer der Teilflamme) festgehalten. In der Variable Flamme [x][4] steht die Zeitverzögerung in Millisekunden. Sie wird ebenfalls via Zufall festgelegt und bestimmt, in welchem Tempo die einzelnen Leuchtdioden nacheinander ein- bzw. ausgeschaltet werden. Somit kann die Flamme variabel, langsam oder schnell auf- und absteigen. Diese zwei Variable verursachen, dass zwischen den drei Teilflammen keine synchronen Abläufe entstehen.
In Arduino IDE stehen drei Anweisungen für Bildung der Zufallszahlen zur Verfügung: random(x), random (x,y) und randomSeed(x). In unserem Beispiel wird die einfachste Funktion random(), die Zufallszahlen zwischen 0 und x liefert, angewendet.

Schieberegister

Der Schieberegister 74HC595 verfügt über acht Ausgänge, die in dem Beispiel unsere Leuchtdioden mit Strom versorgen. Jedes Schieberegister ist mit drei Steuereingängen ausgestattet, die für Steuerung mit einem Mikrocontroller vorgesehen sind. Somit muss der Mikrocontroller mindestens drei Ausgänge zur Verfügung stellen, um den Schieberegister anzusteuern. In unserer Schaltung wird jedes Schieberegister separat angesteuert. Das heißt, es werden insgesamt neun Ausgänge des Mikrocontrollers in Anspruch genommen. Falls der Mikrocontroller nicht über so viele Ausgänge verfügt oder die Ausgänge für andere Zwecke benutzt werden sollen, können alle drei (oder mehr) Schieberegister gemeinsam mit nur drei Steuerausgängen gesteuert werden. Das ist möglich, da die Schieberegister 74HC595 in Reihe geschaltet werden können. Eine solche Lösung nennt man Kaskadenschaltung.

Schaltplan

Programm (Sketch)

int SH_CP_Pin [] = { 2, 6, 10 };                 // 74HC595 Pin 11 Shift Clock
int ST_CP_Pin [] = { 3, 7, 11 };                 // 74HC595 Pin 12 Latch Clock
int DS_Pin [] = { 4, 8, 12 };                    // 74HC595 Pin 14 Data

int Flamme [3][5];                               // [0-2][x] Flamme Nummer
                                                 // [x][0] - Muster abgearbeitet
                                                 // [x][1] - LED - Anzahl
                                                 // [x][2] - Aktuelle Bitposition
                                                 // [x][3] - Bewegung Richtung
                                                 // [x][4] - Zeitverzögerung
int Flamme_Nr;                                   // insgesamt 3 Flammen
unsigned long Flammezeit_alt [3];
unsigned long MillisAktuell = 0;

// *******************************************************************************************
void setup() {
    
    for (int i = 0; i < 3; i++ ) {                    // Definition der Ausgänge
        pinMode(ST_CP_Pin [i], OUTPUT);
        pinMode(SH_CP_Pin [i], OUTPUT);
        pinMode(DS_Pin [i], OUTPUT);
        Flamme [i][0] = 1;                            // Start aktivieren
    }
}

// *******************************************************************************************
void Senden() {

    digitalWrite(ST_CP_Pin [Flamme_Nr], LOW);         // Daten Aufnahme Start 
    for (int i = 8; i > 0; i--) {
        digitalWrite(SH_CP_Pin [Flamme_Nr], LOW);     // Bit Aufnahme erlauben
        int Sende_Bit = 1;
        if (i (*groeser) Flamme [Flamme_Nr][2]) {
            Sende_Bit = 0;
        }     
        digitalWrite(DS_Pin [Flamme_Nr], Sende_Bit);  // Bit schreiben
        digitalWrite(SH_CP_Pin [Flamme_Nr], HIGH);    // Bit übernehmen
    }
    digitalWrite(ST_CP_Pin [Flamme_Nr], HIGH);        // Aufnahme Ende, Ausgänge schalten
}

// *******************************************************************************************
void loop () {

    Flamme_Nr++;
    if (Flamme_Nr (*groeser) 2) { Flamme_Nr = 0; }

    if (Flamme [Flamme_Nr][0] == 1) {                 // Muster abgearbeitet?, neue Parameter
        Flamme [Flamme_Nr][0] = 0;                    // Start
        Flamme [Flamme_Nr][1] = random (1,9);         // Anzahl teilnehmenden LEDs
        Flamme [Flamme_Nr][2] = 0;                    // Aktuelle  Position der Flammenspitze
        Flamme [Flamme_Nr][3] = 0;                    // Bewegung  0-steigend, 1-fallend
        Flamme [Flamme_Nr][4] = random (5,50);        // Zeitverzögerung
        Flammezeit_alt [Flamme_Nr] = millis();        // Zeit aktuell
    }

    if (Flamme [Flamme_Nr][0] == 0) {                 // Flamme Bearbeitung    
        MillisAktuell = millis();                     // Zeit abgelaufen?, nächster Schritt
        if ((MillisAktuell - Flammezeit_alt [Flamme_Nr]) (*groeser) Flamme [Flamme_Nr][4]) {           
            Flammezeit_alt [Flamme_Nr] = millis();    // Zeit festhalten
            if (Flamme [Flamme_Nr][3] == 0) {         //Bewegung rauf
                Flamme [Flamme_Nr][2]++;
            }
            if (Flamme [Flamme_Nr][3] == 1) {          //Bewegung runter
                Flamme [Flamme_Nr][2]--;
            }
            if (Flamme [Flamme_Nr][2] > Flamme [Flamme_Nr][1]) {  // Endpunkt erreicht?
                Flamme [Flamme_Nr][3] = 1;             // Bewegung runter
                Flamme [Flamme_Nr][2]--;
            }                                          // Vorgang abgearbeitet
            if ((Flamme [Flamme_Nr][3] == 1) && (Flamme [Flamme_Nr][2] == 1)) {
                Flamme [Flamme_Nr][0] = 1;             // Frei für neue Parameter
            }
            Senden();                                  // LEDs schalten
        }
    }
}

// *******************************************************************************************    

Testschaltung

LEDs - Anordnung

Wie man auf dem Bild sehen kann, besteht unser Lagerfeuer in der Testschaltung aus vier Teilflammen, doch lediglich drei werden von dem Mikrocontroller gesteuert. Das liegt daran, dass die Teilflamme Nummer 2 einfach geteilt wurde. Beide Teilflammen bestehen jeweils aus vier Leuchtdioden. Zusammengesetzt besteht die Teilflamme zwei genauso wie die zwei andere Teilflammen aus acht Leuchtdioden.
Die Nummerierung der Leuchtdioden ist bei allen drei Teilflammen identisch. Die erste Leuchtdiode (ganz unten) hat die Nummer 1, die letzte (ganz oben) die Nummer 8.

Kurzvideo

Weitere Themen: