Komme Auf Die

Dunkle Seite Der Macht!

Gegen die Infamitäten des Lebens sind die besten Waffen: Tapferkeit, Eigensinn und Geduld.

Die Tapferkeit stärkt, der Eigensinn macht Spaß und die Geduld gibt Ruhe. Hermann Hesse (1877 - 1962)

This Is VaderBase

Chestbox: Let there Deee-Lite...

Und Gott sagte: "Es werde Licht!". Chuck Norris antwortete: "Sag' 'Bitte'."

               

Früher war mehr Beleuchtung

Oder eben nicht.ten. Denn die ANH chestbox war so gar nicht beleuchtet. Ab ESB hingegen wurden die Lampen angestellt. Über Geschwindigkeit und Abfolge sind schon eine Menge Beobachtungen gemacht worden.

Was soll das bedeuten?

Die Schriftzeichen sollen laut Herrn Prowse umgedrehte hebräische Zeichen sein, deren Bedeutung nicht bekannt sei. Die Knöpfe habe erkennbare keine Funktion und es sollte auch kein Zuschauer auf die Idee kommen, dem Herrn Vader zu nahe zu treten und "am Radio herumspielen" zu wollen.

  

Es gibt Chestboxen aus Resin, Holz und auch auch CNC-gefrästem Aluminium. In ANH sieht die Chestbox reichlich uneben aus. Daher wäre eine unebene, gebraucht aussehende Box für den authentischen Look die erste Wahl. Andererseits ist die Aluminium-Chestbox natürlich hochwertiger und es kann kaum etwas von den fest verschraubten Detailstückchen ('Greebles') abfallen oder von unverschämten Kindern abgefummelt werden. Nachteil: die Alu-Kiste sieht zu perfekt, eben und makellos aus.

 

   

Hier das erstaunliche Script (darf nur von mir verwendet werden...):

// 78 bpm ermittelt mit google-metronom, berechnet jedoch 80 bpm

// Eingangsmusik mit drei Varianten: Imperial March mit hoher Wahrscheinlichkeit, Back in Black seltener, Rickrolling ganz selten.

//Testlauf mit allen LEDs animiert, um Funktion überprüfen lassen zu können durch Benutzer. Technischer Selbsttest bei LEDs weder sinnvoll noch zuverlässig möglich

//Vier Modi:

//ANH (entspricht aus), ESB. Beides OT, natürlich.

//beide Modi gedimmt möglich mit Extra-Schalter. Schalterwechsel setzt Werte einmalig auf 0, um Synchronität zu sichern.

// ANH ist immer an, lebenslange Garantie und ewige Energieversorgung gesichert. Muhahaha

//per Zufall werden 0 bis 5 LEDs angeschaltet

//alle LEDs werden gefadet beim Ein- und Ausschalten

//per Zufall bleiben LEDS einen Zyklus länger an

//Überschneidungen würden zu Flackern aufgrund der digitalen Ansteuerung führen. Vermeidung erfolgreich.

//Synchrones Leuchten im Takt erfolgreich. Millis-jittering vermieden.

 

int m = 0; // Musik-Zufallszahl

int d = 0; //delay für Testlaufegschwindigkeit

int i = 0; // Durchläufe für Testlauf

 

const int buttonPin = 7;     // the number of the pushbutton pin

const int ledPin =  8;      // the number of the LED pin

int buttonState = 0;         // variable for reading the pushbutton status

 

int p = 0; //flag für einmaligen Reset, also einmaligen Durchlauf der while-Schleife, der Parameter nach Wechsel des Helligkeitsmodus

int q = 0; //flag für einmaligen Reset, also einmaligen Durchlauf der while-Schleife, der Parameter nach Wechsel des Helligkeitsmodus

 

int to = 2; // Variable für Ton-Pin

 

int z1 = 3; //Pins mit normaler Helligkeit, für Pin 7, 8, 9

int z2 = 3;

int z3 = 3;

int z4 = 3;

int z5 = 3;

int z6 = 3;

 

int z1dim = 3; //Pin gedimmt (rechte Seite; Pin 10, 11, 12)

int z2dim = 3;

int z3dim = 3;

int z4dim = 3;

int z5dim = 3;

int z6dim = 3;

 

 

 

 

int zx = 6; //Zahlenbereich für Zufallszahlen. Somit Häufigkeit der ausgeschalteten LEDS, je höher der Wert von 6 (Werte 0 bis 5 -> [+7=  PIN 7 bis 12]) nach oben abweicht.

int ledlangan = 3; //wie häufig soll die LED länger an bleiben (zwei Takte). 5 bedeutet 50:50. 9 bedeutet weniger häufig, 1 bedeutet sehr häufig.

 

int stay1 = 0; //flag für längeren Modus (anhaltende Helligkeit statt Auf- und Abblinken)

int stay2 = 0;

int stay3 = 0;

int stay4 = 0;

int stay5 = 0;

 

int stay11 = 0;

int stay22 = 0;

int stay33 = 0;

int stay44 = 0;

int stay55 = 0;

 

int stay111 = 0;

int stay222 = 0;

int stay333 = 0;

int stay444 = 0;

int stay555 = 0;

 

int zxstay1 = 0; //Zufallszahl für Ermittlung, ob längerer Modus eintritt oder nicht

int zxstay2 = 0;

int zxstay3 = 0;

int zxstay4 = 0;

int zxstay5 = 0;

 

 

int LED1fertig = 0; //flag für Ende des Zyklus. Wenn Fertig = 1, dann neuer Pin

int LED2fertig = 0;

int LED3fertig = 0;

int LED4fertig = 0;

int LED5fertig = 0;

int LED6fertig = 0;

 

int LED1fertigdim = 0; //flag für Zyklus im Dimmodus. Wenn Fertig = 1, dann neuer Pin.

int LED2fertigdim = 0;

int LED3fertigdim = 0;

int LED4fertigdim = 0;

int LED5fertigdim = 0;

int LED6fertigdim = 0;

 

 

// define directions for LED fade

#define UP 0

#define DOWN 1

 

int hell_hi = 50; //wird genutzt, um nicht maxPWM1 und maxPWM1dim etc. einzeln anpassen zu müssen für Testzwecke

int hell_dim = 10;

 

// constants for min and max PWM

 int minPWM1 = 0;

 int maxPWM1 = hell_hi;

 int minPWM1dim = 0;

 int maxPWM1dim = hell_dim;

 

 int minPWM2 = 0;

int maxPWM2 = hell_hi;

 int minPWM2dim = 0;

 int maxPWM2dim = hell_dim;

 

 int minPWM3 = 0;

 int maxPWM3 = hell_hi;

 int minPWM3dim = 0;

 int maxPWM3dim = hell_dim;

 

 int minPWM4 = 0;

 int maxPWM4 = hell_hi;

 int minPWM4dim = 0;

 int maxPWM4dim = hell_dim;

 

 int minPWM5 = 0;

 int maxPWM5 = hell_hi;

 int minPWM5dim = 0;

 int maxPWM5dim = hell_dim;

 

const int minPWM6 = 0; // wird in ESB nicht genutzt, da max. fünf Lampen an sind.

const int maxPWM6 = 250;

 

// State Variable for Fade Direction

byte fadeDirection1 = UP;

byte fadeDirection2 = UP;

byte fadeDirection3 = UP;

byte fadeDirection4 = UP;

byte fadeDirection5 = UP;

byte fadeDirection6 = UP;

 

// Global Fade Value

// but be bigger than byte and signed, for rollover

int fadeValue1 = 0;

int fadeValue2 = 0;

int fadeValue3 = 0;

int fadeValue4 = 0;

int fadeValue5 = 0;

int fadeValue6 = 0;

 

int increment = 1; //wird genutzt, um für Testzwecke nicht fadeIncrement1 bis 6 sowie fadeIncrement1dim einzeln festlegen zu müssen.

int incrementdim = 1;

 

// How smooth to fade?

byte fadeIncrement1 = increment;

byte fadeIncrement2 = increment;

byte fadeIncrement3 = increment;

byte fadeIncrement4 = increment;

byte fadeIncrement5 = increment;

byte fadeIncrement6 = increment;

byte fadeIncrement1dim = incrementdim;

byte fadeIncrement2dim = incrementdim;

byte fadeIncrement3dim = incrementdim;

byte fadeIncrement4dim = incrementdim;

byte fadeIncrement5dim = incrementdim;

byte fadeIncrement6dim = incrementdim;

 

 

int delayhi = 8; //Intervalzeit Helle LEDs (muss gleiche Zeit ergeben mit Anzahl der Zyklen für synchrones Blinken)

int delaylo = 40; //Intervallzeit dunkle LEDs

 

int stayhi = 101; //Anzahl der Zyklen für die anhaltende Helligkeit im hellen Modus. Muss gleich Zeit ergeben, damit LEDs synchron blinken

int staylo = 21; //dunkler Modus

 

// millis() timing Variable, just for fading

unsigned long previousFadeMillis1;

unsigned long previousFadeMillis2;

unsigned long previousFadeMillis3;

unsigned long previousFadeMillis4;

unsigned long previousFadeMillis5;

unsigned long previousFadeMillis6;

 

// How fast to increment?

int fadeInterval1 = delayhi;

int fadeInterval2 = delayhi;

int fadeInterval3 = delayhi;

int fadeInterval4 = delayhi;

int fadeInterval5 = delayhi;

int fadeInterval6 = delayhi;

int fadeInterval1dim = delaylo;

int fadeInterval2dim = delaylo;

int fadeInterval3dim = delaylo;

int fadeInterval4dim = delaylo;

int fadeInterval5dim = delaylo;

int fadeInterval6dim = delaylo;

 

void setup() {

 

  randomSeed(analogRead(0));//ordentliche Zufallszahl

   Serial.begin(9600);

  while(!Serial);

 // Serial.println("Programm startet");

 

 

m = random(1000); //Zufall für Musik

//Serial.println(m);

if ((m<=1000) && (m>=300)){ //IMPERIAL MARCH

 

 

 

for(q = 0 ; q <=2; q +=1){

analogWrite(3,255);

d = 90;

delay(d);

analogWrite(5,255);

tone(to,330,500);

delay(d);

analogWrite(6,255);

delay(d);

analogWrite(11,255);

delay(d);

analogWrite(10,255);

delay(d);

analogWrite(9,255);

delay(d);

analogWrite(3,0);

delay(d);

analogWrite(5,0);

delay(d);

analogWrite(6,0);

delay(d);

analogWrite(11,0);

delay(d);

analogWrite(10,0);

delay(d);

analogWrite(9,0);}

 

delay(200);

 

for(q = 0 ; q <= 1; q +=1){

 for(i = 3 ; i <= 11; i +=1){

      analogWrite(i, 255);}

  //delay(100);

   tone(to,262,400);

  delay(600);

  tone(to,392,100);

  delay(300);

  tone(to,330,400);

  delay(600);

 

   for(i = 11 ; i >= 3; i -=1){

     analogWrite(i, 0);}

  delay(450);}

}

 

if ((m<300) && (m>250)){ //RICKROLLING

 

 

 

for(q = 0 ; q <=2; q +=1){

analogWrite(3,255);

d = 90;

delay(d);

analogWrite(5,255);

tone(to,335,500);

delay(d);

analogWrite(6,255);

delay(d);

analogWrite(11,255);

delay(d);

analogWrite(10,255);

delay(d);

analogWrite(9,255);

delay(d);

analogWrite(3,0);

delay(d);

analogWrite(5,0);

delay(d);

analogWrite(6,0);

delay(d);

analogWrite(11,0);

delay(d);

analogWrite(10,0);

delay(d);

analogWrite(9,0);}

 

delay(200);

 

 

 

   tone(to,262,400);

  delay(600);

  tone(to,392,100);

  delay(300);

  tone(to,330,400);

  analogWrite(3,255);analogWrite(5,255);analogWrite(6,255);analogWrite(9,255);analogWrite(10,255);analogWrite(11,255);

  delay(800);

 analogWrite(3,0);analogWrite(5,0);analogWrite(6,0);analogWrite(9,0);analogWrite(10,0);analogWrite(11,0);

   tone(to,262,400);

  delay(600);

  tone(to,392,100);

  delay(300);

 

 

 tone(to,349,100);  //F

  delay(200);

  analogWrite(3,255);

   tone(to,392,100);  //G

  delay(200);

  analogWrite(5,255);

   tone(to,466,100);  //AIS

  delay(200);

  analogWrite(10,255);

   tone(to,392,100);  //G

  delay(200);

  analogWrite(11,255);

   tone(to,587,400);  //D

  delay(500);

  analogWrite(6,255);

   tone(to,587,400);  //D

  delay(500);

  analogWrite(9,255);

   tone(to,523,800);  //C

  delay(900);

analogWrite(3,0);

 tone(to,349,100);  //F

  delay(200);

  analogWrite(11,0);

   tone(to,392,100);  //G

  delay(200);

  analogWrite(5,0);

   tone(to,466,100);  //AIS

  delay(200);

  analogWrite(3,255);

   tone(to,392,100);  //G

  delay(200);

  analogWrite(10,0);

   tone(to,523,400);  //C

  delay(500);

  analogWrite(10,255);

   tone(to,523,400);  //C

  delay(500);

  analogWrite(10,0);

   tone(to,466,300);  //AIS

  delay(400);

  analogWrite(3,255);

 tone(to,440,100);  //A

  delay(200);

  analogWrite(6,0);

  tone(to,392,200);  //G

  delay(300);

  analogWrite(9,0);

 

 

   tone(to,349,100);  //F

  delay(200);

  analogWrite(11,255);

   tone(to,392,100);  //G

  delay(200);

  analogWrite(3,255);

   tone(to,466,100);  //AIS

  delay(200);

  analogWrite(6,255);

   tone(to,392,100);  //G

  delay(200);

  analogWrite(9,255);

   tone(to,392,400);  //G

  delay(500);

  analogWrite(5,255);

 

     tone(to,523,200);  //C

  delay(300);

  analogWrite(9,0);

     tone(to,349,400);  //F

  delay(500);

  analogWrite(3,0);

     tone(to,349,400);  //F

  delay(500);

  analogWrite(5,0);

     tone(to,349,200);  //F

  delay(300);

  analogWrite(10,255);

tone(to,523,400);  //C

  delay(500);

  analogWrite(9,255);

     tone(to,466,800);  //G

  delay(900);

analogWrite(3,0);analogWrite(5,0);analogWrite(6,0);analogWrite(9,0);analogWrite(10,0);analogWrite(11,0);

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 if (m<=250) {  //BACK IN BLACK

 tone(to,329,300); // E

 delay(800);

 analogWrite(3,255);

 tone(to,294,100);  //D

 delay(200);

 analogWrite(5,255);

 tone(to,294,100);  //D

 delay(200);

  analogWrite(6,255);

 tone(to,294,500);  //D

 delay(700);

  analogWrite(9,255);

 tone(to,277,100);  //CIS

 delay(200);

  analogWrite(10,255);

 tone(to,277,100);  //CIS

 delay(200);

  analogWrite(11,255);

 tone(to,277,500);  //CIS

 delay(1600);

 analogWrite(6,0);

 tone(to,392,100);  //G

  delay(200);

  analogWrite(11,0);

 tone(to,329,100);  //E

  delay(200);

  analogWrite(5,0);

 tone(to,294,100);  //D

  delay(200);

   analogWrite(6,255);

 tone(to,247,100);  //H

  delay(200);

  analogWrite(5,255);

 tone(to,220,100);  //A

  delay(400);

analogWrite(9,0); 

 tone(to,196,100);  //G

 delay(200);

 

  tone(to,329,300);  //G

analogWrite(3,0);

analogWrite(5,0);

analogWrite(6,0);

analogWrite(9,0);

analogWrite(10,0);

analogWrite(11,0);

 

 

 

 

 

 

 

 

 

 

}

 

 

 

  delay(1000);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  // put pwmLED into known state (off)

  analogWrite(z1, fadeValue1);

  analogWrite(z2, fadeValue2);

  analogWrite(z3, fadeValue3);

  analogWrite(z4, fadeValue4);

  analogWrite(z5, fadeValue5);

  analogWrite(z6, fadeValue6);

 

 

  // pinMode(ledPin, OUTPUT);     

  // initialize the pushbutton pin as an input:

  pinMode(buttonPin, INPUT);  

 

}

 

void doTheFade1(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis1 >= fadeInterval1) {

    // yup, it's time!

    if (fadeDirection1 == UP) {

      fadeValue1 = fadeValue1 + fadeIncrement1; 

      if (fadeValue1 >= maxPWM1) {

        // At max, limit and change direction

    // zxstay1 = random(10);

      //  Serial.println(zxstay1);

    if (zxstay1 >= ledlangan) {

 

                              fadeValue1 = hell_hi;

                              stay1 = (stay1 + 1);

                             if (stay1 >= stayhi) {

       

                  fadeValue1 = maxPWM1;

                  fadeDirection1 = DOWN;

                  stay1 = 0;}

    }

 

if (zxstay1 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

    fadeValue1 = maxPWM1;

   fadeDirection1 = DOWN;

  stay1 = 0;

   }

    }

  //    }

    } else {

      //if we aren't going up, we're going down

      fadeValue1 = fadeValue1 - fadeIncrement1;

      if (fadeValue1 <= minPWM1) {

        // At min, limit and change direction

        fadeValue1 = minPWM1;

        //fadeDirection1 = UP;

stay11 = (stay11 + 1);

if (stay11 >= stayhi){

          fadeDirection1 = UP;

       LED1fertig = 1;

       stay11 = 0;}

zxstay1 = random(10);

      }

    }

    // Only need to update when it changes

 

    analogWrite(z1, fadeValue1); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED1fertig == 1) {

      z1 = random(zx);

     // z1 = (z1 + 7);

     if (z1 == 5){

      z1 = 11;

     }

       if (z1 == 4){

      z1 = 10;

     }

       if (z1 == 3){

      z1 = 9;

     }

       if (z1 == 2){

      z1 = 6;

     }

       if (z1 == 1){

      z1 = 5;

     }

       if (z1 == 0){

      z1 = 3;

     }

                  if (z1 == z2) {

        z1 = 14;

      }

                  if (z1 == z3) {

        z1 = 14;

      }

                  if (z1 == z4) {

        z1 = 14;

      }

                  if (z1 == z5) {

        z1 = 14;

      }

      LED1fertig = 0;

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis1 = (previousFadeMillis1 + delayhi);

  }

}

 

 

void doTheFade1dim(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis1 >= fadeInterval1dim) {

    // yup, it's time!

    if (fadeDirection1 == UP) {

      fadeValue1 = fadeValue1 + fadeIncrement1dim; 

      if (fadeValue1 >= maxPWM1dim) {

        // At max, limit and change direction

      // zxstay1 = random(10);

      //  Serial.println(zxstay1);

        if (zxstay1 >= ledlangan) {

 

fadeValue1 = hell_dim;

 stay1 = (stay1 + 1);

 if (stay1 >= staylo) {

       

        fadeValue1 = maxPWM1dim;

        fadeDirection1 = DOWN;

        stay1 = 0;}

        }

 

if (zxstay1 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue1 = maxPWM1dim;

        fadeDirection1 = DOWN;

        stay1 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue1 = fadeValue1 - fadeIncrement1dim;

      if (fadeValue1 <= minPWM1dim) {

        // At min, limit and change direction

        fadeValue1 = minPWM1dim;

        stay111 = (stay111 + 1);

        if (stay111 >= staylo){

        fadeDirection1 = UP;

       LED1fertigdim = 1;

       stay111 = 0;

zxstay1 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z1, fadeValue1); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED1fertigdim == 1) {

      z1 = random(zx);

      //z1 = (z1 + 7);

            if (z1 == 5){

      z1 = 11;

     }

       if (z1 == 4){

      z1 = 10;

     }

       if (z1 == 3){

      z1 = 9;

     }

       if (z1 == 2){

      z1 = 6;

     }

       if (z1 == 1){

      z1 = 5;

     }

       if (z1 == 0){

      z1 = 3;

     }

              if (z1 == z2) {

        z1 = 14;

      }

               if (z1 == z3) {

        z1 = 14;

      }

                if (z1 == z4) {

        z1 = 14;

      }

                  if (z1 == z5) {

        z1 = 14;

      }

      LED1fertigdim = 0;

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis1 = (previousFadeMillis1 + delaylo);

  }

}

 

 

void doTheFade2(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis2 >= fadeInterval2) {

    // yup, it's time!

    if (fadeDirection2 == UP) {

      fadeValue2 = fadeValue2 + fadeIncrement2; 

      if (fadeValue2 >= maxPWM2) {

        // At max, limit and change direction

      // zxstay2 = random(10);// hier nicht

      //  Serial.println(zxstay1);

    if (zxstay2 >= ledlangan) {

 

fadeValue2 = hell_hi;

 stay2 = (stay2 + 1);

 if (stay2 >= stayhi) {

       

        fadeValue2 = maxPWM2;

        fadeDirection2 = DOWN;

        stay2 = 0;}

     }

 

if (zxstay2 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

      fadeValue2 = maxPWM2;

    fadeDirection2 = DOWN;

    stay2 = 0;

    //  }

    }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue2 = fadeValue2 - fadeIncrement2;

      if (fadeValue2 <= minPWM2) {

        // At min, limit and change direction

        fadeValue2 = minPWM2;

        stay22 = (stay22 + 1);

        if (stay22 >= stayhi){

         

       

        fadeDirection2 = UP;

       LED2fertigdim = 1;

       stay22 = 0;

zxstay2 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z2, fadeValue2); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED2fertigdim == 1) {

      z2 = random(zx);

     // z2 = (z2 + 7);

           if (z2 == 5){

      z2 = 11;

     }

       if (z2 == 4){

      z2 = 10;

     }

       if (z2 == 3){

      z2 = 9;

     }

       if (z2 == 2){

      z2 = 6;

     }

       if (z2 == 1){

      z2 = 5;

     }

       if (z2 == 0){

      z2 = 3;

     }

      LED2fertigdim = 0;

            if (z2 == z1) {

        z2 = 15;

      }

            if (z2 == z3) {

        z2 = 15;

      }

        if (z2 == z4) {

        z2 = 15;

      }

              if (z2 == z5) {

        z2 = 15;

      }

 

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis2 = (previousFadeMillis2 + delayhi);

  }

}

 

 

void doTheFade2dim(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis2 >= fadeInterval2dim) {

    // yup, it's time!

    if (fadeDirection2 == UP) {

      fadeValue2 = fadeValue2 + fadeIncrement2dim; 

      if (fadeValue2 >= maxPWM2dim) {

        // At max, limit and change direction

     //  zxstay2 = random(10);

      //  Serial.println(zxstay1);

        if (zxstay2 >= ledlangan) {

 

fadeValue2 = hell_dim;

 stay2 = (stay2 + 1);

 if (stay2 >= staylo) {

       

        fadeValue2 = maxPWM2dim;

        fadeDirection2 = DOWN;

        stay2 = 0;}

        }

 

if (zxstay2 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue2 = maxPWM2dim;

        fadeDirection2 = DOWN;

        stay2 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue2 = fadeValue2 - fadeIncrement2dim;

      if (fadeValue2 <= minPWM2dim) {

        // At min, limit and change direction

        fadeValue2 = minPWM2dim;

        stay222 = (stay222 + 1);

        if (stay222 >= staylo) {

         

       

        fadeDirection2 = UP;

        stay222 = 0;

       LED2fertig = 1;

zxstay2 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z2, fadeValue2); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED2fertig == 1) {

      z2 = random(zx);

   //   z2 = (z2 + 7);

          if (z2 == 5){

      z2 = 11;

     }

       if (z2 == 4){

      z2 = 10;

     }

       if (z2 == 3){

      z2 = 9;

     }

       if (z2 == 2){

      z2 = 6;

     }

       if (z2 == 1){

      z2 = 5;

     }

       if (z2 == 0){

      z2 = 3;

     }

      LED2fertig = 0;

      if (z2 == z1) {

        z2 = 15;

      }

 

        if (z2 == z3) {

        z2 = 15;

      }

          if (z2 == z4) {

        z2 = 15;

      }

          if (z2 == z5) {

        z2 = 15;

      }

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis2 = (previousFadeMillis2 + delaylo);

  }

}

 

 

 

 

 

 

 

void doTheFade3(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis3 >= fadeInterval3) {

    // yup, it's time!

    if (fadeDirection3 == UP) {

      fadeValue3 = fadeValue3 + fadeIncrement3; 

      if (fadeValue3 >= maxPWM3) {

        // At max, limit and change direction

      //zxstay3 = random(10);// hier nicht

      //  Serial.println(zxstay1);

     if (zxstay3 >= ledlangan) {

 

fadeValue3 = hell_hi;

 stay3 = (stay3 + 1);

 if (stay3 >= stayhi) {

       

        fadeValue3 = maxPWM3;

        fadeDirection3 = DOWN;

        stay3 = 0;}

     }

 

if (zxstay3 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

      fadeValue3 = maxPWM3;

     fadeDirection3 = DOWN;

      stay3 = 0;

  }

 //     }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue3 = fadeValue3 - fadeIncrement3;

      if (fadeValue3 <= minPWM3) {

        // At min, limit and change direction

        fadeValue3 = minPWM3;

        stay33 = (stay33 + 1);

        if (stay33 >= stayhi){

         

       

        fadeDirection3 = UP;

       LED3fertigdim = 1;

       stay33 = 0;

      zxstay3 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z3, fadeValue3); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED3fertigdim == 1) {

      z3 = random(zx);

    //  z3 = (z3 + 7);

              if (z3 == 5){

      z3 = 11;

     }

       if (z3 == 4){

      z3 = 10;

     }

       if (z3 == 3){

      z3 = 9;

     }

       if (z3 == 2){

      z3 = 6;

     }

       if (z3 == 1){

      z3 = 5;

     }

       if (z3 == 0){

      z3 = 3;

     }

      LED3fertigdim = 0;

            if (z3 == z1) {

        z3 = 16;

      }

            if (z3 == z2){

        z3 = 16;

      }

 if (z3 == z4){

        z3 = 16;

      }

 if (z3 == z5){

        z3 = 16;

      }

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis3 = (previousFadeMillis3 + delayhi);

  }

}

 

 

void doTheFade3dim(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis3 >= fadeInterval3dim) {

    // yup, it's time!

    if (fadeDirection3 == UP) {

      fadeValue3 = fadeValue3 + fadeIncrement3dim; 

      if (fadeValue3 >= maxPWM3dim) {

        // At max, limit and change direction

     //zxstay3 = random(10); // nee, nee, nee

      //  Serial.println(zxstay1);

        if (zxstay3 >= ledlangan) {

 

fadeValue3 = hell_dim;

 stay3 = (stay3 + 1);

 if (stay3 >= staylo) {

       

        fadeValue3 = maxPWM3dim;

        fadeDirection3 = DOWN;

        stay3 = 0;}

        }

 

if (zxstay3 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue3 = maxPWM3dim;

        fadeDirection3 = DOWN;

        stay3 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue3 = fadeValue3 - fadeIncrement3dim;

      if (fadeValue3 <= minPWM3dim) {

        // At min, limit and change direction

        fadeValue3 = minPWM3dim;

        stay333 = (stay333 + 1);

        if (stay333 >= staylo){

         

       

        fadeDirection3 = UP;

       LED3fertig = 1;

       stay333 = 0;

 zxstay3 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z3, fadeValue3); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED3fertig == 1) {

      z3 = random(zx);

     // z3 = (z3 + 7);

          if (z3 == 5){

      z3 = 11;

     }

       if (z3 == 4){

      z3 = 10;

     }

       if (z3 == 3){

      z3 = 9;

     }

       if (z3 == 2){

      z3 = 6;

     }

       if (z3 == 1){

      z3 = 5;

     }

       if (z3 == 0){

      z3 = 3;

     }

      LED3fertig = 0;

      if (z3 == z1) {

        z3 = 16;

      }

 

            if (z3 == z2){

        z3 = 16;

      }

 

  if (z3 == z4){

        z3 = 16;

      }

        if (z3 == z5){

        z3 = 16;

      }

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis3 = (previousFadeMillis3 + delaylo);

  }

}

 

 

 

 

void doTheFade4(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis4 >= fadeInterval4) {

    // yup, it's time!

    if (fadeDirection4 == UP) {

      fadeValue4 = fadeValue4 + fadeIncrement4; 

      if (fadeValue4 >= maxPWM4) {

        // At max, limit and change direction

    //   zxstay4 = random(10); // hier nicht

      //  Serial.println(zxstay1);

        if (zxstay4 >= ledlangan) {

 

fadeValue4 = hell_hi;

 stay4 = (stay4 + 1);

 if (stay4 >= stayhi) {

       

        fadeValue4 = maxPWM4;

        fadeDirection4 = DOWN;

        stay4 = 0;}

        }

 

if (zxstay4 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue4 = maxPWM4;

        fadeDirection4 = DOWN;

        stay4 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue4 = fadeValue4 - fadeIncrement4;

      if (fadeValue4 <= minPWM4) {

        // At min, limit and change direction

        fadeValue4 = minPWM4;

        stay44 = (stay44 + 1);

        if (stay44 >= stayhi){

         

       

        fadeDirection4 = UP;

       LED4fertigdim = 1;

       stay44 = 0;

zxstay4 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z4, fadeValue4); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED4fertigdim == 1) {

      z4 = random(zx);

     // z4 = (z4 + 7);

          if (z4 == 5){

      z4 = 11;

     }

       if (z4 == 4){

      z4 = 10;

     }

       if (z4 == 3){

      z4 = 9;

     }

       if (z4 == 2){

      z4 = 6;

     }

       if (z4 == 1){

      z4 = 5;

     }

       if (z4 == 0){

      z4 = 3;

     }

      LED4fertigdim = 0;

            if (z4 == z1) {

        z4 = 17;

      }

            if (z4 == z2){

        z4 = 17;

      }

 if (z4 == z3){

        z4 = 17;

      }

 if (z4 == z5){

        z4 = 17;

      }

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis4 = (previousFadeMillis4 + delayhi);

  }

}

 

 

void doTheFade4dim(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis4 >= fadeInterval4dim) {

    // yup, it's time!

    if (fadeDirection4 == UP) {

      fadeValue4 = fadeValue4 + fadeIncrement4dim; 

      if (fadeValue4 >= maxPWM4dim) {

        // At max, limit and change direction

   //   zxstay4 = random(10); // hier doch nicht. Bringt alles durcheinander.

      //  Serial.println(zxstay1);

        if (zxstay4 >= ledlangan) {

 

fadeValue4 = hell_dim;

 stay4 = (stay4 + 1);

 if (stay4 >= staylo) {

       

        fadeValue4 = maxPWM4dim;

        fadeDirection4 = DOWN;

        stay4 = 0;}

        }

 

if (zxstay4 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue4 = maxPWM4dim;

        fadeDirection4 = DOWN;

        stay4 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue4 = fadeValue4 - fadeIncrement4dim;

      if (fadeValue4 <= minPWM4dim) {

        // At min, limit and change direction

        fadeValue4 = minPWM4dim;

        stay444 = (stay444 + 1);

        if (stay444 >= staylo){

        fadeDirection4 = UP;

       LED4fertig = 1;

       stay444 = 0;

zxstay4 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z4, fadeValue4); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED4fertig == 1) {

      z4 = random(zx);

     // z4 = (z4 + 7);

          if (z4 == 5){

      z4 = 11;

     }

       if (z4 == 4){

      z4 = 10;

     }

       if (z4 == 3){

      z4 = 9;

     }

       if (z4 == 2){

      z4 = 6;

     }

       if (z4 == 1){

      z4 = 5;

     }

       if (z4 == 0){

      z4 = 3;

     }

      LED4fertig = 0;

      if (z4 == z1) {

        z4 = 17;

      }

 

            if (z4 == z2){

        z4 = 17;

      }

 

      if (z4 == z3){

        z4 = 17;

      }

 

 if (z4 == z5){

        z4 = 17;

      }

 

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis4 = (previousFadeMillis4 + delaylo);

  }

}

 

 

 

 

void doTheFade5(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis5 >= fadeInterval5) {

    // yup, it's time!

    if (fadeDirection5 == UP) {

      fadeValue5 = fadeValue5 + fadeIncrement5; 

      if (fadeValue5 >= maxPWM5) {

        // At max, limit and change direction

      // zxstay5 = random(10); // hier nicht

      //  Serial.println(zxstay1);

        if (zxstay5 >= ledlangan) {

 

fadeValue5 = hell_hi;

 stay5 = (stay5 + 1);

 if (stay5 >= stayhi) {

       

        fadeValue5 = maxPWM5;

        fadeDirection5 = DOWN;

        stay5 = 0;}

        }

 

if (zxstay5 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue5 = maxPWM5;

        fadeDirection5 = DOWN;

        stay5 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue5 = fadeValue5 - fadeIncrement5;

      if (fadeValue5 <= minPWM5) {

        // At min, limit and change direction

        fadeValue5 = minPWM5;

        stay55 = (stay55 + 1);

        if (stay55 >= stayhi){

         

       

        fadeDirection5 = UP;

       LED5fertigdim = 1;

       stay55 = 0;

  zxstay5 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z5, fadeValue5); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED5fertigdim == 1) {

      z5 = random(zx);

    //  z5 = (z5 + 7);

         if (z5 == 5){

      z5 = 11;

     }

       if (z5 == 4){

      z5 = 10;

     }

       if (z5 == 3){

      z5 = 9;

     }

       if (z5 == 2){

      z5 = 6;

     }

       if (z5 == 1){

      z5 = 5;

     }

       if (z5 == 0){

      z5 = 3;

     }

      LED5fertigdim = 0;

            if (z5 == z1) {

        z5 = 18;

      }

            if (z5 == z2){

        z5 = 18;

      }

 if (z5 == z3){

        z5 = 18;

      }

 

 if (z5 == z4){

        z5 = 18;

      }

 

 

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis5 = (previousFadeMillis5 + delayhi);

  }

}

 

 

void doTheFade5dim(unsigned long thisMillis) {

  // is it time to update yet?

  // if not, nothing happens

  if (thisMillis - previousFadeMillis5 >= fadeInterval5dim) {

    // yup, it's time!

    if (fadeDirection5 == UP) {

      fadeValue5 = fadeValue5 + fadeIncrement5dim; 

      if (fadeValue5 >= maxPWM5dim) {

        // At max, limit and change direction

    //  zxstay5 = random(10); // hier nicht. Echt nicht.

      //  Serial.println(zxstay1);

        if (zxstay5 >= ledlangan) {

 

fadeValue5 = hell_dim;

 stay5 = (stay5 + 1);

 if (stay5 >= staylo) {

       

        fadeValue5 = maxPWM5dim;

        fadeDirection5 = DOWN;

        stay5 = 0;}

        }

 

if (zxstay5 < ledlangan) {

 

       // fadeValue1 = 255;

       // stay1 = (stay1 + 1);

       // if (stay1 >= 103) {

       

        fadeValue5 = maxPWM5dim;

        fadeDirection5 = DOWN;

        stay5 = 0;

    //  }

      }

      }

    } else {

      //if we aren't going up, we're going down

      fadeValue5 = fadeValue5 - fadeIncrement5dim;

      if (fadeValue5 <= minPWM5dim) {

        // At min, limit and change direction

        fadeValue5 = minPWM5dim;

        stay555 = (stay555 + 1);

        if (stay555 >= staylo){

         

       

        fadeDirection5 = UP;

       LED5fertig = 1;

       stay555 = 0;

zxstay5 = random(10);

      }}

    }

    // Only need to update when it changes

 

    analogWrite(z5, fadeValue5); 

//Serial.println("1");

//Serial.println(fadeValue1);

    if (LED5fertig == 1) {

      z5 = random(zx);

     // z5 = (z5 + 7);

          if (z5 == 5){

      z5 = 11;

     }

       if (z5 == 4){

      z5 = 10;

     }

       if (z5 == 3){

      z5 = 9;

     }

       if (z5 == 2){

      z5 = 6;

     }

       if (z5 == 1){

      z5 = 5;

     }

       if (z5 == 0){

      z5 = 3;

     }

      LED5fertig = 0;

      if (z5 == z1) {

        z5 = 18;

      }

 

            if (z5 == z2){

        z5 = 18;

      }

 

      if (z5 == z3){

        z5 = 18;

      }

  if (z5 == z4){

        z5 = 18;

      }

 

 

 

    }

   

 

 

    // reset millis for the next iteration (fade timer only)

    previousFadeMillis5 = (previousFadeMillis5 + delaylo);

  }

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

//void doTheFade6(unsigned long thisMillis6) {

//  // is it time to update yet?

//  // if not, nothing happens

//  if (thisMillis6 - previousFadeMillis6 >= fadeInterval6) {

//    // yup, it's time!

//    if (fadeDirection6 == UP) {

//      fadeValue6 = fadeValue6 + fadeIncrement6; 

//      if (fadeValue6 >= maxPWM6) {

//        // At max, limit and change direction

//        fadeValue6 = maxPWM6;

//        fadeDirection6 = DOWN;

//      }

//    } else {

//      //if we aren't going up, we're going down

//      fadeValue6 = fadeValue6 - fadeIncrement6;

//      if (fadeValue6 <= minPWM6) {

//        // At min, limit and change direction

//        fadeValue6 = minPWM6;

//        fadeDirection6 = UP;

//       LED6fertig = 1;

//

//      }

//    }

//    // Only need to update when it changes

//

//   // analogWrite(z6, fadeValue6); 

//

//    if (LED6fertig == 1) {

//   //  z6 = random(zx);

//      z6 = (z6 + 7);

//      LED6fertig = 0;

//    }

//   

// //Serial.println(z1);

// //Serial.println( fadeValue1);

//

//    // reset millis for the next iteration (fade timer only)

//    previousFadeMillis6 = thisMillis6;

//  }

//}

 

 

 

 

 

 

 

 

void loop() {

  // get the current time, for this time around loop

  // all millis() timer checks will use this time stamp

  unsigned long currentMillis = millis();

if ((z1 == 9) || (z1 == 10) || (z1 == 11)){

 doTheFade1dim(currentMillis);

}

 

if ((z1 == 3) || (z1 == 5) || (z1 == 6)  ){

doTheFade1(currentMillis);

}

 

if ((z1 >= 13)){

 doTheFade1dim(currentMillis);

}

 

if ((z2 == 9) || (z2 == 10) || (z2 == 11)){

doTheFade2dim(currentMillis);

}

 

if ((z2 == 3) || (z2 == 5) || (z2 == 6) ){

doTheFade2(currentMillis);

}

if ((z2 >= 13)){

 doTheFade2dim(currentMillis);

}

 

if ((z3 == 9) || (z3 == 10) || (z3 == 11)){

  doTheFade3dim(currentMillis);

}

 

if ((z3 == 3) || (z3 == 5) || (z3 == 6) ){

doTheFade3(currentMillis);

}

if ((z3 >= 13)){

  doTheFade3dim(currentMillis);

}

 

 

if ((z4 == 9) || (z4 == 10) || (z4 == 11)){

  doTheFade4dim(currentMillis);

}

 

if ((z4 == 3) || (z4 == 5) || (z4 == 6) ){

doTheFade4(currentMillis);

}

if ((z4 >= 13)){

  doTheFade4dim(currentMillis);

}

 

if ((z5 == 9) || (z5 == 10) || (z5 == 11)){

  doTheFade5dim(currentMillis);

}

 

if ((z5 == 3) || (z5 == 5) || (z5 == 6)){

doTheFade5(currentMillis);

}

if ((z5 >= 13)){ //wenn Zufallszahl höher, dann PIN ohne LED

  doTheFade5dim(currentMillis);

}

//Serial.println("z1 bis z3");

//Serial.println(z1);

//Serial.println(z2);

//Serial.println(z3);

//Serial.println(fadeValue1);

 

//Serial.println(fadeValue2);

 

//Serial.println(fadeValue3);

//Serial.println(z4);

//Serial.println(z5);

 

//doTheFade6(currentMillis);

 

 buttonState = digitalRead(buttonPin);

 

  // check if the pushbutton is pressed.

  // if it is, the buttonState is HIGH:

if (buttonState == HIGH) {    // Schalter AN

    // turn LED on:       // Kontroll-LED AN

 digitalWrite(ledPin, HIGH);

while (q < 1) {

 

fadeValue1 = 0;

fadeValue2 = 0;

fadeValue3 = 0;

fadeValue4 = 0;

fadeValue5 = 0;

fadeValue6 = 0;

stay1 = 0;

 stay2 = 0;

 stay3 = 0;

stay4 = 0;

stay5 = 0;

 

stay11 = 0;

 stay22 = 0;

stay33 = 0;

stay44 = 0;

stay55 = 0;

 

 stay111 = 0;

stay222 = 0;

 stay333 = 0;

 stay444 = 0;

stay555 = 0;

 

 

 

 

 

 

 

z1 = 3;

 z2 = 3;

 z3 = 3;

 z4 = 3;

z5 = 3;

 z6 = 3;

 LED1fertig = 0;

 LED2fertig = 0;

 LED3fertig = 0;

 LED4fertig = 0;

LED5fertig = 0;

LED6fertig = 0;

 

 LED1fertigdim = 0;

LED2fertigdim = 0;

 LED3fertigdim = 0;

 LED4fertigdim = 0;

LED5fertigdim = 0;

 LED6fertigdim = 0;

 

 

q++;

p=0;

 

}

 

 

// constants for min and max PWM

minPWM1 = 0;

maxPWM1 = 250;

minPWM1dim = 0;

maxPWM1dim = 20;

 

minPWM2 = 0;

maxPWM2 = 250;

 minPWM2dim = 0;

maxPWM2dim = 20;

 

minPWM3 = 0;

maxPWM3 = 250;

minPWM3dim = 0;

 maxPWM3dim = 20;

 

 minPWM4 = 0;

 maxPWM4 = 250;

 minPWM4dim = 0;

 maxPWM4dim = 20;

 

 minPWM5 = 0;

maxPWM5 = 250;

minPWM5dim = 0;

maxPWM5dim = 20;

 

fadeIncrement1 = 5;

fadeIncrement2 = 5;

fadeIncrement3 = 5;

fadeIncrement4 = 5;

fadeIncrement5 = 5;

fadeIncrement6 = 5;

 

 fadeIncrement1dim = 1;

 fadeIncrement2dim = 1;

 fadeIncrement3dim = 1;

fadeIncrement4dim = 1;

fadeIncrement5dim = 1;

fadeIncrement6dim = 1;

 

fadeInterval1 = 8;

 fadeInterval2 = 8;

 fadeInterval3 = 8;

 fadeInterval4 = 8;

 fadeInterval5 = 8;

 fadeInterval6 = 8;

fadeInterval1dim = 20;

fadeInterval2dim = 20;

 fadeInterval3dim = 20;

 fadeInterval5dim = 20;

fadeInterval6dim = 20;

 stayhi = 101;

staylo = 41;

delayhi = 8;

delaylo = 20;

hell_hi = 250;

hell_dim = 20;

 

 }

 

  if (buttonState == LOW) { //Schalter AUS

      digitalWrite(ledPin, LOW); // Kontroll-LED AUS

while (p< 1) {

 

 fadeValue1 = 0;

 fadeValue2 = 0;

 fadeValue3 = 0;

fadeValue4 = 0;

fadeValue5 = 0;

fadeValue6 = 0;

stay1 = 0;

 stay2 = 0;

 stay3 = 0;

stay4 = 0;

stay5 = 0;

z1 = 3;

 z2 = 3;

 z3 = 3;

 z4 = 3;

z5 = 3;

 z6 = 3;

 

stay11 = 0;

 stay22 = 0;

stay33 = 0;

stay44 = 0;

stay55 = 0;

 

 stay111 = 0;

stay222 = 0;

 stay333 = 0;

 stay444 = 0;

stay555 = 0;

 

 

 

  LED1fertig = 0;

 LED2fertig = 0;

 LED3fertig = 0;

 LED4fertig = 0;

LED5fertig = 0;

LED6fertig = 0;

 

 LED1fertigdim = 0;

LED2fertigdim = 0;

 LED3fertigdim = 0;

 LED4fertigdim = 0;

LED5fertigdim = 0;

 LED6fertigdim = 0;

p++;

q=0;

}

 

// constants for min and max PWM

 minPWM1 = 0;

 maxPWM1 = 50;

minPWM1dim = 0;

 maxPWM1dim = 10;

 

minPWM2 = 0;

 maxPWM2 = 50;

 minPWM2dim = 0;

 maxPWM2dim = 10;

 

 minPWM3 = 0;

 maxPWM3 = 50;

 minPWM3dim = 0;

 maxPWM3dim = 10;

 

 minPWM4 = 0;

 maxPWM4 = 50;

 minPWM4dim = 0;

 maxPWM4dim = 10;

 

 minPWM5 = 0;

 maxPWM5 = 50;

 minPWM5dim = 0;

 maxPWM5dim = 10;

 

 fadeIncrement1 = 1;

fadeIncrement2 = 1;

 fadeIncrement3 = 1;

 fadeIncrement4 = 1;

 fadeIncrement5 = 1;

fadeIncrement6 = 1;

 

 fadeIncrement1dim = 1;

 fadeIncrement2dim = 1;

 fadeIncrement3dim = 1;

fadeIncrement4dim = 1;

 fadeIncrement5dim = 1;

fadeIncrement6dim = 1;

 

 fadeInterval1 = 8;

 fadeInterval2 = 8;

 fadeInterval3 = 8;

 fadeInterval4 = 8;

 fadeInterval5 = 8;

 fadeInterval6 = 8;

fadeInterval1dim = 40;

 fadeInterval2dim = 40;

 fadeInterval3dim = 40;

 fadeInterval4dim = 40;

 fadeInterval5dim = 40;

fadeInterval6dim = 40;

 stayhi = 101;

staylo = 21;

 

 delayhi = 8;

 delaylo = 40;

hell_hi = 50;

hell_dim = 10;

 

 

  }

 

 

 

 

 

}

 


Sequenzen

Die Sequenz oder auch nur eben feste Reihenfolge, in der die Lampen (ob es LED waren, ist mir nicht bekannt) die Coinslot genannten Schlitze der Apparatur auf Herrn Vaders Brust beleuchteten ist anhand der Filmquellen nicht zu belegen. Mal ist die Beleuchtung gar nicht an, mal blinken die einzeln, mal gleichzeitig. Eine Wiederholung der Reihenfolge ist nicht auszumachen, daher scheint es keine Sequenz zu geben. Die Vermutung liegt nahe, dass die Lampen zufällig angesteuert werden. Diese Zufälligkeit jedoch lässt Parameter erkennen: die Schnelligkeit scheint festzuliegen, auch bestimmte Verhaltensweisen der Anzahl der angeschalteten Lampen. Daraus ergeben sich zwei Herangehensweisen: eine Simulation der erkennbaren Eigenschaften (z.B. werden nie beide Lampen eines Slots gleichzeitig angeschaltet) mit zufälliger Ausgestaltung oder eben eine Imitation der im Film sichtbaren Abläufe.

 

Beide Variationen sind möglich mittels einer aufgefeilten Konstellation von Elektronikbauteilen oder mittels der Programmierung eins Minicomputers wie den Arduino.

Rot oder gelb?

In manchen Szene wirkt ein Coinslot gelb statt rot. Ich vermute, dass es sich hier um einen Effekt handelt, der der Aufnahmetechnik, Beleuchtung oder grob gesprochen der der Physik geschuldet ist (Interferenzen). Eine konstante Beleuchtung eines Coinslots in einer abweichenden Farbe habe nicht erkennen können. Zusätzlich meine ich mich an eine Aufnahme zu erinnern, in der ein kostümierter Vader-Fan in einem Kinofoyer ebensfalls eine zeitweise gelbe Leuchte an der Brust zu haben schien. Da dieses Thema jedoch wenig publik ist, gehe ich von optischen Effekten aus, die dieses Changieren hervorrufen.

 

Probleme?

Was gab es nicht alles für Schwierigkeiten mit dieser Programmierung. Millis-jitter (langsam steigernde Abweichungen des Takts; nicht mehr synchrone Leds... sehr zwielichtig), komplette delay-Befehl-Untauglichkeit für das Ein- und Ausdimmen mehrerer Leds gleichzeitig sowie angemessener Schalterabfragezeiträume, abrauchende Boards (mal langsam, mal schnell) durch falsche/ missverständliche Anschlüsse oder Spannungen, falsche Pin-Reihenfolgen (daher andere Reihenfolge und Zuordnung notwendig), fehlende Pulldownwiderstände (dadurch chaotisches Schalterverhalten) und ständig dieses Led-Geflacker hervorgerufen durch doppelte Ansteuerung einer Led (pwm sei Dank). Ganz vorne auf der Liste der WFT-Momente auch die wahnsinnig witzige Idee vom FTDI, ungefragt die Treiber zu akutalisieren und so zu sabotieren, dass alle Clones des Arduino Nano V3 komplett die Kommunikation von USB zum Comport einstellen.  Doof nur, wenn man gar nicht weiß, dass man einen Clone besitzt und einfach so von heute auf morgen nichts mehr geht und keinen blassen Schimmer hat, warum. Naja, FTDI-Zwangsschrott habe ich entsorgt und bin auf CH340-µC umgestiegen. Nun klappt's auch wieder mit dem Nachbarn.

 Lauter Dinge, die bei analoger Ansteuerung nicht vorkommen. Aber da ich diese 555-Timer-Counter-Widerstand-Kondensator-Elektroniknummer nicht verstehe und ich auch nicht wüsste, wie man damit komplexere Dinge erstellen kann (wie z.B. die Musik), stütze ich mich halt auf die Mikroprozessorvariante. Ach ja, für die Musik habe ich mir angeschaut, wie jemand den Imperial March und Back in Black auf dem Klavier spielt. Dann die Tasten notiert, Noten herausgesucht, Frequenz der Note zugeordnet und als Wert dem tone-Befehl samt Dauer für die Piezo-Lautsprecheransteuerung eingegeben. Dann noch viel mit den Zeiten herumgespielt bis es passte. (Kann ja leider keine Noten lesen). Das legendäre dritte Lied (welches nur sehr selten gespielt wird per Zufallssteuerung) war zudem am längsten und fummeligsten. Hat sich aber gelohnt. :-)