#8 Leuchtstofflampen

mit zufälligem flackern

In Teil 8 der Arduino Reihe wollen wir das Flackern simulieren wenn eine Leuchtstofflampe an geht. Dies Realisieren wir gleich für 10 Ausgänge, egal ob diese gebraucht werden oder nicht.

Außerdem bauen wir noch ein gimmig ein, welches ein Ausgang in unregelmäßigen abständen kurz flackern lässt.

Was brauchen wir:

- Ein Arduino (Uno, Pro Mini oder ähnlich)

- USB Kable zum verbinden mit dem PC

- die Arduino IDE Software

- LEDs (bzw Laternen)

- Wiederstände für die LEDs

Für den Versuchsaufbau:

- Breadboard

- Breadboard Kabel

Zum Programm:

zunächst werden alle Variablen Definiert:

In -> der Eingang welcher dem Arduino sagt das die Lichter angehen sollen

AlleAn -> hier Speichern wir, dass nach dem ersten kurzen Flackern alle Lampen an sind

out -> bestimmt welcher Ausgang An bzw Aus geht

outDefekt -> legt fest welcher Ausgang dauerhaft flackern soll

Pause1 -> Flackerintervall während des anschaltens

Pause2 -> Flackerintervall der "Defekten" Lampe

EinAus -> hierrüber wird beim anschalten bestimmt ob die Lampe kurz flackern soll oder nicht.

void setup()

Den Setup Bereich kennen wir ja schon.

PinModes festlegen und schon mal (für Testzwecke) die Serielle Schnittstelle anschmeißen.

void loop()

Zunächst kümmern wir uns um das Anschalten der Lampen. Wenn an Pin2 ein Signal anliegt und die Lampen nicht schon an sind, wird die if-Schleife für das Start-Flackern aufgerufen.

Darin starten wir eine for-Schleife diese hilft uns das Start-Flackern auch wieder zu beenden. Insgesammt wollen wir max 100 Statusänderungen bis alle Leuchten entgültig an sind.

Dann holen wir uns ein paar Zufallswerte. Da der Arduino schlecht in sowas ist, nutzen wir das Rauschen eines Analogen Eingangs als randomSeed.

Wir brauchen einen Ausgang dessen Status wir ändern (Wert zwischen 3 und 12), eine Zeit die wir bis zur nächsten Änderung warten (wert zwischen 5 und 50ms) und eine Zufallswert der Entscheidet obe der Ausgang an oder aus gehen soll (0=aus 1-8=an).

In der daurauffolgenden if/else-Schleife schalten wir den Ausgang nun an oder eben aus.

Dann warten wir die zufällige Zeit ab.

Kommen wir dann aus dieser ersten for-Schleife heraus gehen wir in die nächste um wirklich alle Lampen an zu haben bevor wir die Start-Sequenz verlassen.

Vor dem Verlassen setzten wir AlleAn = true um uns zu merken das wir die Start-Sequenz durchlaufen haben.

Außerdem wird noch ein zufälliger Wert generiert. Dieser bestimmt welcher Ausgang später Flackern soll.

Sollte am Pin2 kein Signal anliegen, schalten wir in dieser if-Schleife alle Lampen aus. Und speichern uns den Zustand AlleAn = false ab. Dadurch wird beim nächsten mal die Start-Sequnz wieder durchlaufen.

Nun zum Flackern eines Ausgangs. Der Ausgang welcher flackern soll wurde ja schon in die Variable outDefekt geschrieben. Nun fragen wir obe diese Lampe an oder aus IST, dementsprechend wird sie nun aus- bzw angeschaltet.

Außerdem wird die Variable Pause2 mit einem zufälligen Wert beschrieben. In deiser werden die Millisekunden festgehlaten welche vergehn sollen bis zur nächsten Statusänderung der Ausgangs.

Spielt einfach mit den Werten bis es euch gefällt.

Nun noch ein Hack: delays können nich unterbrochen werden. Lässt man aber eine for-Schleife mit einem delay von einer Millisekunde laufen, kann man diese for-Schleife unterbrechen. Dazu zetzt man die Endbedingung einfach selbst. Dies macht man in einer if-Schleife welche die "Exit"-bedingung enthält.

int In = 2;
int AlleAn = false;
int out;
int outDefekt;
int Pause1;
int Pause2;
int EinAus;

void setup() {
pinMode(2,INPUT_PULLUP);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(12,OUTPUT);
Serial.begin(9600);
}

void loop() {
//-----------------------------------------------
//-Alle Lampen an mit Zufälligem Flackern--
//-----------------------------------------------
if ((digitalRead(In)) == HIGH && AlleAn == false) {
    for (int i=0; i<100; i++){
      randomSeed(analogRead(0));
      out = random(3, 12);
      Pause1 = random(5, 50);
      EinAus = random(0, 8);
      if (EinAus > 0){
        digitalWrite(out,HIGH);
      }
      else{
        digitalWrite(out,LOW);
      }
      delay(Pause1);

}

    for(out=3;out<12;out++){
    digitalWrite(out,HIGH);
    AlleAn = true;

    }
//-----------------------------------------------
//----Welche Lampe soll später flackern----
//-----------------------------------------------
    randomSeed(analogRead(0)+millis());
    outDefekt = random(3, 12);
    Serial.println(outDefekt);
}

//-----------------------------------------------
//-------------Alle Leuchten aus--------------
//-----------------------------------------------
if ((digitalRead(In)) == LOW){
    for(out=3;out<12;out++){
      digitalWrite(out,LOW);
      AlleAn = false;
    }
}
//-----------------------------------------------
//------Zufälliges Flackern einer Lampe------
//-----------------------------------------------
if (AlleAn == true){
    if (digitalRead(outDefekt) == HIGH){
      digitalWrite(outDefekt, LOW);
      Pause2 = random(300, 1000);
    }
    else{
      digitalWrite(outDefekt, HIGH);
      Pause2 = random(5, 300);
    }