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;
}
}
Komme Auf Die
Dunkle Seite Der Macht!