Arduino Arduino - Blaulicht einmal anders

[Stephan_56]

Hallo Forum,

dank Gismow (Peter), der mich notwenigerweise vom delay() zum switch führte, habe ich weiter im Internet gesucht.
Was einem dabei immer wieder über den Weg läuft, sind die delay()s bei Blinkschaltungen.
Einer Eingebung folgend suchte ich mal nach "blinken ohne delay" und wurde fündig unter
http://playground.arduino.cc/Learning/BlinkWithoutDelay_de

Wenn im Titel auch das Blaulicht steht, so gilt dies uneingeschränkt auch für das Gelblicht und im Prinzip auch für alle zeitlichen Steuerungen, die kein delay() vertragen oder wo es sich nachteilig auswirkt.

Die heutigen Blaulichtschaltungen finde ich eher langweilig. Ein - aus, Flip - Flop. Hat etwas Billiges und finde ich persönlich eintönig und auf der Straße eher wenig Aufmerksamkeit erregend. Zumal diese LED Steuerungen bei starkem Sonnenlicht, starkem Regen, Nebel und Schneefall nicht besonders weit sichtbar sind - außer bei Dunkelheit. Halt synchrones Blinken. Zwar versucht man gerade bei Rettungsfahrzeugen durch Front- und Seitenblitzer ein gewisses unruhiges Signalbild zu erzeugen, bleibt aber insgesamt langweilig.
Die Blinklichter, die jedoch mit Xenon-Blitzen arbeiten, sind m. E. wesentlich besser sichtbar, weil sie durch die intensiven Blitze eher die Aufmerksamkeit auf sich ziehen. Sie werden einzeln angesteuert und sind ggf. auch abhängig davon, wie sich die Mechanik (nicht bei Xenon) bewegt. Dadurch entsteht eine gewisse Asychonität.
Auch bei den Modellbauangeboten sind die Blinker meist synchron, wobei es auch Anbieter gibt (Pistenking), wo man die Blinkfolge asynchron einstellen kann.
Dieses asynchrone Blinken wollte ich nachbilden und ich denke, es ist mir gelungen.
Den o.a. Link zum Blinken ohne Delay habe ich erweitert / modifiziert.
Es werden jetzt zwei TOP Blaulichter asynchron betrieben, davon unabhängig ein Frontstrobo (als LED) und zwei parallele Frontblitzer.
Denkbar sind noch andere Effekte, die, bei gleicher Machart, unabhängig voneinander laufen können. Selbst Ansteuerungen für Begleitfahrzeuge für Schwertransporte (Stichwort: BF3) sind denkbar.
Als LED empfehle ich in 5mm diese und für 3mm diese
Die LED's haben ein klares Gehäuse aber 10.000 (5mm) und 5.000(3mm) mcd und "beißen" richtig, wenn man reinschaut. Mit blauem Rundumlichtgehäuse kommt das richtig gut.

Hier der Sektch:

    /* Blinken ohne "delay()"
     *
     * Ursprung:
     * http://playground.arduino.cc/Learning/BlinkWithoutDelay_de
     * 
     * Die "neuen" Blaulichter laufen m. E. primitiv synchron.
     * Flip - Flop - Ein - Aus - wie langweilig!
     * Dies ist eine Modifikation/Erweiterung des o.a. Sketches.
     * Hier laufen über die RANDOM-Funktion zwei Blaulichter asynchron
     * Ein drittes Blaulicht läuft ebenfalls frei nebenher
     * Ein viertes/fünftes Blaulicht (Frontblitzer) ist ebenfalls realisiert
     * Diese Blaulichter laufen so meist bei der Autobahnpolizei, sofern die Blaulichter
     * mit Xenon-Lampen betrieben werden. 2 Blaulichter rundum auf dem TOP, ein 3. nach vorne wirkendes 
     * als Stroboskop.
     * Vorteil hier: der Sketch wird nicht durch delay() zum warten verurteilt, sondern kann
     * nebenbei noch andere Aufgaben erledigen.
     * Dieser Sketch kann beliebig mit zusätzlichen Synchronstrobos o.ä. nachgerüstet werden,
     * wenn auf gleiche Art eingebaut.
     */
     
    byte ledPin1 = 3; // 1. LED liegt an Pin 3
    byte ledPin2 = 4; // 2. LED liegt an Pin 4
    byte ledPin3 = 5; // 3. LED liegt an Pin 5
    byte ledPin4 = 6; // 4. LED liegt an Pin 6
    boolean value1 = HIGH; // Startwert der 1. LED
    boolean value2 = LOW; // Startwert der 2. LED
    boolean value3 = LOW; // Startwert der 3. LED
    boolean value4 = LOW; // Startwert der 4. LED
    unsigned long previousMillis1 = 0; // speichert, wie viele Sekunden seit derletzten Änderung vergangen sind
    unsigned long previousMillis2 = 0; // wie vor für 2. Blaulicht
    unsigned long previousMillis3 = 120; // wie vor für 3. Blaulicht
    unsigned long previousMillis4 = 0; // wie vor für Flasher
    unsigned long interval1 = random(200,400); // Interval zwischen zwei Änderungen für LED 1
    unsigned long interval2= random(200,400);  // wie vor für LED 2
    unsigned long interval3= 120; // wie vor für LED 3
    unsigned long interval4=80;    // wie vor für LED 4/5

    
    void setup()
    {
      pinMode(ledPin1, OUTPUT); // Setzt den ledPin1 (Pin 3) als Ausgang
      pinMode(ledPin2, OUTPUT); // Setzt den ledPin2 (Pin 4) als Ausgang
      pinMode(ledPin3, OUTPUT); // Setzt den ledPin3 (Pin 5) als Ausgang
      pinMode(ledPin4, OUTPUT); // Setzt den ledPin4 (Pin 6) als Ausgang
      /*
      * wenn analog-pin 0 frei ist, wird aus dem am (unbeschaltetem) Pin anliegenden Rauschen der
      * Wert für den Zufallsgenerator gelesen und ist so bei jedem Einschalten unterschiedlich.
      * randomSeed() startet und mischt dann die Zufallsfunktion.
      */
      int randomSeed(analogRead(0));
    }
     
    void loop()
    {
      /* es wird kontrolliert, ob die Zeiten für die Blink-Intervalle schon abgelaufen sind
      * Wenn die Zeitdifferenz zwischen dem letzten Abspeichern und der aktuellen Zeit größer
      * als das Intervall ist, so wird die nachfolgende Funktion ausgeführt.
      */

      if (millis() - previousMillis1 > interval1) 
      {
        previousMillis1 = millis(); // aktuelle Zeit abspeichern
     
        // LED Zustand wecheln.
        value1 = !value1;

        // Intervall zwischen 200 und 299 ms jedesmal neu setzen
        unsigned long interval1 = random(200,300);      
        
        // Wert auf den Ausgang schreiben
        digitalWrite(ledPin1, value1);
      }
      if (millis() - previousMillis2 > interval2) 
      {
        previousMillis2 = millis(); // aktuelle Zeit abspeichern
     
        // LED Zustand wecheln.
        value2 = !value2;

        // Intervall zwischen 280 und 379ms neu setzen
        unsigned long interval2= random(280,380);     
        
        // Wert auf den Ausgang schreiben
        digitalWrite(ledPin2, value2);
      }
      if (millis() - previousMillis3 > interval3) 
      {
        previousMillis3 = millis(); // aktuelle Zeit abspeichern
        
        // LED Zustand wechseln
        value3 = !value3;
        // Wert auf den Ausgang schreiben
        digitalWrite(ledPin3,value3);
       }
      if (millis() - previousMillis4 > interval4)
      {
	previousMillis4 = millis(); // aktuelle Zeit abspeichern
		  
	// LEDs Zustand wechseln
	value4 = !value4;
	 
	// Interval zwischen 30 und 79ms neu setzen
	unsigned long interval4=random(30,80);
	// Wert auf den Ausgang schreiben
	digitalWrite(ledPin4,value4);
      }
    }
// END

und die Verdrahtung



Wer trotzdem alles synchron laufen lassen will, der entferne die RANDOM-Werte und setze jeweils gleiche Werte für die jeweiligen Schleifen.
Viel Spaß!