Quellcode für Schneeflocken-Weihnachtslicht

/*
*Projektname: Schneeflocke
*Funktionen: Ermöglicht das Blinken von 36 blauen LEDs in mehreren Modi *
*Version: V1.2
*Beschreibung: Notizen hinzufügen
*/
#include <TimerOne.h>

Byte m = 0; //Modus2 Sondervariable
Byte P-Wert = 0; // Helligkeitsvariable für atmendes Licht
boolean BreatheFlag = true; //Atmungslicht Helligkeitsänderungsrichtung Byte ModeNumber = 0; //Modusnummer
boolean AutoModeFlag = false; //Automatische Änderungsmoduskennung
//Byte alteModusnummer = 0;
Boolesche Touchflag = falsch;
vorzeichenlose Ganzzahl Zeit1 = 0;
vorzeichenlose Ganzzahl Zeit2 = 0;
vorzeichenlose Ganzzahl timex = 0;

const byte Ring[5][7]={ {9,10,5}, {8,13,16},

{17,19,12,4,14,7}, {18,2,15}, {11,3,6}
};

void setup() {
Seriell.begin(9600);
für(int i=0;i<5;i++){
für(int j=0;Ring[i][j]!='\0';j++){

pinMode(Ring[i][j],AUSGABE); }

}
Timer1.initialize( 100000 ); // Initialisierung, Intervall verwendet Mikrosekunden als Einheit Timer1.attachInterrupt( Timer1Interrupt ); // füge die Serviceroutine hier an }

// die Setup-Funktion wird einmal ausgeführt, wenn Sie Reset drücken oder die Karte einschalten void Timer1Interrupt(void){
if((analogRead(A6) > 600) && (Touchflag==false)){

Touchflag = wahr;
Zeit1 = Millis();
if(!AutoModeFlag){ //Modus im Nicht-AUTO-Modus um 1 erhöhen ModeNumber = ModeNumber + 1;
wenn(Modusnummer == 2) m = 0;
wenn(Modusnummer == 13) Modusnummer = 0;
}
//Serial.println(Modusnummer);
}
sonst wenn((analogRead(A6) < 600) und (Touchflag==true)){ Touchflag = false;
Zeitx = Millis() – Zeit1;
wenn(Zeitx > 2000){

ModeNumber = 0; AutoModeFlag = false; }
}

}

// die Loop-Funktion wird immer und immer wieder ausgeführt void loop() {
wenn(AutoModeFlag){

Zeitx = Millis() - Zeit2; wenn(Zeitx > 5000){ ModeNumber++; Zeit2 = Millis();

}
wenn(Modusnummer == 12){ AutoModeFlag = false; Modusnummer = 0;
}
}
Schalter(Modusnummer){

true bedeutet Aufhellung

false bedeutet Ausblenden

Fall 0:
Fall 1:
Fall 2:
Fall 3:
Fall 4:
Fall 5:
Fall 6:
Fall 7:
Fall 8:
Fall 9:
Fall 10: Mode10(100); Unterbrechung; Fall 11: Mode6(60); Unterbrechung; Fall 12: Mode0();

Mode0(); Unterbrechung; Mode1(20); Unterbrechung; Mode7(100); Unterbrechung; Mode2(100); Unterbrechung; Mode8(100); Unterbrechung; Mode11(80); Unterbrechung; Mode4(100); Unterbrechung; Mode3(100); Unterbrechung; Mode5(10); Unterbrechung; Mode9(100); Unterbrechung;

//true bedeutet, dass sich ein Finger auf dem TouchPad befindet
//Zeit aufzeichnen1 (zum Herunterfahren länger als 2 Sekunden gedrückt halten)
//Aufzeichnungszeit2 (um die Präsentationszeit jedes Modus im AUTO-Modus zu berechnen) //Aufzeichnungszeitraum (gemeinsam mit Zeit1 und Zeit2)

Verzögerung(1000); Modusnummer = 1; AutoModusFlag = wahr; Zeit2 = Millis(); Pause;

Standard: Unterbrechung; }

}

/*****************************Funktion für Lichtmodus 0 Funktionsname:Modus0
Funktionsmerkmal: Alle Lichter ausschalten
Eingabeparameter: keine

Ausgabeparameter: keine ******************************************/ void Mode0(void)
{
Ring_Run(0,false);
Ring_Run(1,false);
Ring_Run(2,false);
Ring_Run(3,false);
Ring_Run(4,false);
}

/*****************************Funktion Lichtmodus 1
Funktionsname:Mode1
Funktionsmerkmal: Äußerer Ring, der Licht atmet (interne Verzögerung von 10 ms) Eingabeparameter: Helligkeitsänderungsintervall int Mytime
Ausgabeparameter:
*****************************************/
void Mode1(int Mytime)
{
analogWrite(Ring[4][1],P-Wert);
analogWrite(Ring[4][2],P-Wert);
wenn(BreatheFlag==true){

analogSchreiben(Ring[4][0],255-PWert); analogSchreiben(Ring[0][2],255-PWert); PWert = PWert + 1;
wenn(P-Wert == 255) BreatheFlag = false; }

wenn(BreatheFlag==false){ analogWrite(Ring[4][0],255-Pvalue); analogWrite(Ring[0][2],255-Pvalue); Pvalue = Pvalue - 1;

wenn(P-Wert == 0) BreatheFlag = wahr; }
Verzögerung(10);
}

/*****************************Funktion Lichtmodus 2
Funktionsname:Mode2
Funktionsmerkmal: Vom inneren Ring zum äußeren Ring/vom äußeren Ring zum inneren Ring. Allmähliches Auf- und Ableuchten (im Inneren gibt es eine Verzögerung von etwa 5 s). Eingabeparameter:
Ausgabeparameter:
*****************************************/
void Mode2(int Mytime)
{
Schalter(m){

Fall 0:
Fall 1:
Fall 2:
Fall 3:
Fall 4:
Fall 5:
Fall 6:
Fall 7:
Fall 8:
Fall 9:
Fall 10: Verzögerung(4*MeineZeit); Unterbrechung; Fall 11: Ring_Run(4,falsch); Unterbrechung; Fall 12: Verzögerung(MeineZeit); Unterbrechung; Fall 13: Ring_Run(3,falsch); Unterbrechung; Fall 14: Verzögerung(2*MeineZeit); Unterbrechung; Fall 15: Ring_Run(2,falsch); Unterbrechung; Fall 16: Verzögerung(3*MeineZeit); Unterbrechung; Fall 17: Ring_Run(1,falsch); Unterbrechung; Fall 18: Verzögerung(4*MeineZeit); Unterbrechung; Fall 19: Ring_Run(0,falsch); Unterbrechung; Fall 20: Verzögerung(4*MeineZeit); Unterbrechung; Fall 21: Verzögerung(4*MeineZeit); Unterbrechung; Standard: Unterbrechung;

Ring_Run(0,true); Unterbrechung; Verzögerung(4*MeineZeit); Unterbrechung; Ring_Run(1,true); Unterbrechung; Verzögerung(3*MeineZeit); Unterbrechung; Ring_Run(2,true); Unterbrechung; Verzögerung(2*MeineZeit); Unterbrechung; Ring_Run(3,true); Unterbrechung; Verzögerung(MeineZeit); Unterbrechung; Ring_Run(4,true); Unterbrechung; Verzögerung(4*MeineZeit); Unterbrechung;

}
m = m + 1;
wenn(m == 22) m = 0; }

/*****************************Funktion Lichtmodus 3
Funktionsname:Mode3
Funktionsmerkmal: Volles helles Blinken (mit einer internen Verzögerung von 200 ms) Eingabeparameter: Blinkender Halbzyklus in Mytime
Ausgabeparameter:
*****************************************/
void Mode3(int Mytime)
{
Ring_Run(0,wahr);
Ring_Run(1,wahr);
Ring_Run(2,true);
Ring_Run(3,wahr);
Ring_Run(4,wahr);
Verzögerung(Meine Zeit);
Ring_Run(0,false);
Ring_Run(1,false);
Ring_Run(2,false);
Ring_Run(3,false);
Ring_Run(4,false);
Verzögerung(Meine Zeit);
}

/*****************************Funktion für Lichtmodus 4 Funktionsname:Modus4
Funktionsmerkmal: Die LED an den Blütenblättern leuchtet abwechselnd. Eingabeparameter: Konvertierungszeitintervall int Mytime. Ausgabeparameter: **************************** **************/

void Mode4(int Mytime)
{ Leaf_Run(2,falsch);Leaf_Run(0,wahr);Verzögerung(MeineZeit); Leaf_Run(0,falsch);Leaf_Run(1,wahr);Verzögerung(MeineZeit); Leaf_Run(1,falsch);Leaf_Run(2, true);Verzögerung(MeineZeit); }

/*****************************Funktion für Lichtmodus 5 Funktionsname:Modus5
Funktionsmerkmal: Super Spin Light 1
Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: *************************************** ***/

void Mode5(int Mytime)
{
digitalWrite(Ring[0][2],NIEDRIG);digitalWrite(Ring[0][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[0][0],NIEDRIG);digitalWrite(Ring[0][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[0][1],NIEDRIG);digitalWrite(Ring[0][2],HOCH);Verzögerung(MeineZeit);
digitalWrite(Ring[0][2],LOW);
digitalWrite(Ring[1][1],NIEDRIG);digitalWrite(Ring[1][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[1][0],NIEDRIG);digitalWrite(Ring[1][2],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[1][2],NIEDRIG);digitalWrite(Ring[1][1],HOCH);Verzögerung(MeineZeit);
digitalWrite(Ring[1][1],NIEDRIG); digitalWrite(Ring[2][4],NIEDRIG);digitalWrite(Ring[2][5],NIEDRIG);digitalWrite(Ring[2][2],HOCH);digitalWrite(Ring[2][3],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][2],NIEDRIG);digitalWrite(Ring[2][3],NIEDRIG);digitalWrite(Ring[2][0],HOCH);digitalWrite(Ring[2][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][0],NIEDRIG);digitalWrite(Ring[2][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][1],NIEDRIG);digitalWrite(Ring[2][4],HOCH);digitalWrite(Ring[2][5],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][4],LOW);digitalWrite(Ring[2][5],LOW);
digitalWrite(Ring[3][2],NIEDRIG);digitalWrite(Ring[3][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[3][0],NIEDRIG);digitalWrite(Ring[3][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[3][1],NIEDRIG);digitalWrite(Ring[3][2],HOCH);Verzögerung(MeineZeit);
digitalWrite(Ring[3][2],LOW);
digitalWrite(Ring[4][2],NIEDRIG);digitalWrite(Ring[4][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[4][0],NIEDRIG);digitalWrite(Ring[4][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[4][1],NIEDRIG);digitalWrite(Ring[4][2],HOCH);Verzögerung(MeineZeit);
digitalWrite(Ring[4][2],LOW);
}

/*****************************Funktion für Lichtmodus 6 Funktionsname:Mode6
Funktionsmerkmal: Doppelte Neutronensternverschränkung Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: keine ******************************************/

void Mode6(int Mytime)
{
Ring_Run(0,wahr);
Ring_Run(4,true); digitalWrite(Ring[2][4],NIEDRIG);digitalWrite(Ring[2][3],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][3],NIEDRIG);digitalWrite(Ring[3][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[3][1],NIEDRIG);digitalWrite(Ring[2][2],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][2],NIEDRIG);digitalWrite(Ring[2][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][1],NIEDRIG);digitalWrite(Ring[3][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[3][0],NIEDRIG);digitalWrite(Ring[2][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][0],NIEDRIG);digitalWrite(Ring[2][5],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[2][5],NIEDRIG);digitalWrite(Ring[3][2],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[3][2],NIEDRIG);digitalWrite(Ring[2][4],HOCH);Verzögerung(MeineZeit);

}

/*****************************Funktion für Lichtmodus 7 Funktionsname:Mode7
Funktionsmerkmal: Doppelte Neutronensternverschränkung Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: keine ******************************************/

void Mode7(int Mytime)
{
Ring_Run(2,false);
Ring_Run(4,true); digitalWrite(Ring[0][2],HOCH);digitalWrite(Ring[1][0],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[0][2],NIEDRIG);digitalWrite(Ring[1][0],NIEDRIG);Verzögerung(MeineZeit); digitalWrite(Ring[0][0],HOCH);digitalWrite(Ring[1][1],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[0][0],NIEDRIG);digitalWrite(Ring[1][1],NIEDRIG);Verzögerung(MeineZeit); digitalWrite(Ring[0][1],HOCH);digitalWrite(Ring[1][2],HOCH);Verzögerung(MeineZeit); digitalWrite(Ring[0][1],NIEDRIG);digitalWrite(Ring[1][2],NIEDRIG);Verzögerung(MeineZeit);

}

/*****************************Funktion für Lichtmodus 8 Funktionsname:Mode8
Funktionsmerkmal: Doppelte Neutronensternverschränkung Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: keine ******************************************/

void Mode8(int Mytime) {
für(int i=0;i<5;i++){

für (int j = 0; Ring [i] [j]! = '\0'; j++) { digitalWrite (Ring [i] [j], HIGH); Verzögerung (Mytime);
}

}
für(int i=0;i<5;i++){
für(int j=0;Ring[i][j]!='\0';j++){

digitalWrite(Ring[i][j],LOW); }

Verzögerung(MeineZeit); }

}

/*****************************Funktion für Lichtmodus 9 Funktionsname:Mode9
Funktionsmerkmal: Doppelte Neutronensternverschränkung Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: keine ******************************************/

void Mode9(int Mytime) {
für(int i=0;i<5;i++){

für (int j = 0; Ring [i] [j]! = '\0'; j++) { digitalWrite (Ring [i] [j], HOCH);

}
Verzögerung(MeineZeit);
}
für(int i=0;i<5;i++){
für (int j = 0; Ring [i] [j]! = '\0'; j++) { digitalWrite (Ring [i] [j], LOW); Verzögerung (Mytime);
}
}

}

/*****************************Funktion für Lichtmodus 10 Funktionsname:Mode10
Funktionsmerkmal: Doppelte Neutronensternverschränkung Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: keine ******************************************/

void Mode10(int Mytime)
{ Ring_Run(0,wahr);Ring_Run(4,falsch);Verzögerung(MeineZeit); Ring_Run(1,wahr);Ring_Run(0,falsch);Verzögerung(MeineZeit); Ring_Run(2,wahr);Ring_Run(1,falsch);Verzögerung(MeineZeit); Ring_Run(3,wahr);Ring_Run(2,falsch);Verzögerung(MeineZeit); Ring_Run(4,wahr);Ring_Run(3,falsch);Verzögerung(MeineZeit); }

/*****************************Funktion für Lichtmodus 11 Funktionsname:Mode11
Funktionsmerkmal: Doppelte Neutronensternverschränkung Eingabeparameter: Konvertierungszeitintervall int Mytime Ausgabeparameter: keine ******************************************/

void Mode11(int Mytime) {
für(int i=0;i<3;i++){

digitalWrite(Ring[1][i],HOCH); digitalWrite(Ring[3][i],HOCH); digitalWrite(Ring[4][i],HOCH); Verzögerung(MeineZeit); digitalWrite(Ring[1][i],NIEDRIG); digitalWrite(Ring[3][i],NIEDRIG); digitalWrite(Ring[4][i],NIEDRIG);

// Verzögerung(MeineZeit); }

Verzögerung(MeineZeit); }

/*****************************LED-Ringbetriebsfunktion Funktionsname:Ring_Run
Funktionsmerkmal: Ein- oder Ausschalten der LED am bezeichneten Ring. Eingabeparameter: bezeichneter Ring Byte n Ein/Aus Boolean k. Ausgabeparameter: ******************************************/

void Ring_Run(byte n,boolean k) {
wenn(k==wahr)

Schalter(n){
Fall 0:
für(int i = 0;i < 3;i++) digitalWrite(Ring[0][i],HIGH); Unterbrechung; Fall 1:
für(int i = 0;i < 3;i++) digitalWrite(Ring[1][i],HIGH); Unterbrechung; Fall 2:
für(int i = 0;i < 6;i++) digitalWrite(Ring[2][i],HIGH); Unterbrechung; Fall 3:
für(int i = 0;i < 3;i++) digitalWrite(Ring[3][i],HIGH); brechen; Fall 4:
für (int i = 0; i < 3; i++) digitalWrite (Ring[4][i], HIGH); Unterbrechung; Standard: Unterbrechung;
}
sonst Schalter(n){
Fall 0:
für(int i = 0;i < 3;i++) digitalWrite(Ring[0][i],LOW); Unterbrechung; Fall 1:
für(int i = 0;i < 3;i++) digitalWrite(Ring[1][i],LOW); Unterbrechung; Fall 2:
für(int i = 0;i < 6;i++) digitalWrite(Ring[2][i],LOW); Unterbrechung; Fall 3:
für(int i = 0;i < 3;i++) digitalWrite(Ring[3][i],LOW); Unterbrechung; Fall 4:
für (int i = 0; i < 3; i++) digitalWrite (Ring[4][i], LOW); Unterbrechung; Standard: Unterbrechung;
}

}

/*****************************LED-Blütenblatt-Betriebsfunktion Funktionsname:Leaf_Run
Funktionsmerkmal: Ein- oder Ausschalten der LED auf dem angegebenen Blütenblatt. Eingabeparameter: Blütenblattnummer Byte n Ein/Aus Boolean k

Ausgabeparameter: ******************************************/ void Leaf_Run(byte n,boolean k)
{
wenn(k==wahr)

Schalter(n){
Fall 0: digitalWrite(Ring[1][0],HOCH); digitalWrite(Ring[2][0],HOCH); digitalWrite(Ring[2][1],HOCH); digitalWrite(Ring[3][0],HOCH); digitalWrite(Ring[4][0],HOCH); Unterbrechung;
Fall 1: digitalWrite(Ring[1][2],HOCH); digitalWrite(Ring[2][5],HOCH); digitalWrite(Ring[2][4],HOCH); digitalWrite(Ring[3][2],HOCH); digitalWrite(Ring[4][2],HOCH); Unterbrechung;
Fall 2: digitalWrite(Ring[1][1],HOCH); digitalWrite(Ring[2][2],HOCH); digitalWrite(Ring[2][3],HOCH); digitalWrite(Ring[3][1],HOCH); digitalWrite(Ring[4][1],HOCH); Unterbrechung;
Standard: Unterbrechung;
}
sonst Schalter(n){
Fall 0: digitalWrite(Ring[1][0],LOW); digitalWrite(Ring[2][0],LOW); digitalWrite(Ring[2][1],LOW); digitalWrite(Ring[3][0],LOW); digitalWrite(Ring[4][0],LOW); Unterbrechung;
Fall 1: digitalWrite(Ring[1][2],LOW); digitalWrite(Ring[2][5],LOW); digitalWrite(Ring[2][4],LOW); digitalWrite(Ring[3][2],LOW); digitalWrite(Ring[4][2],LOW); Unterbrechung;
Fall 2: digitalWrite(Ring[1][1],LOW); digitalWrite(Ring[2][2],LOW); digitalWrite(Ring[2][3],LOW); digitalWrite(Ring[3][1],LOW); digitalWrite(Ring[4][1],LOW); Unterbrechung;
Standard: Unterbrechung;
}

}