LED Tannenbaum

Guten Abend,

ich wollte einen kleinen Tannenbaum (zum basteln) mit bunten LEDs bestücken…

Dafür wollte ich verschiedene Sequenzen machen und eine davon, solle in Schichten sein (siehe Skizze “Tannenbaum in Schichten”)

Die Schichten habe ich so beschrieben:

int ebeneEins[] = {2,3};                   //2 LEDs
int ebeneZwei[] = {4};                     //1 LED
int ebeneDrei[] = {5,6};                   //2 LEDs
int ebeneVier[] = {7,8};                   //2 LEDs
int ebeneFuenf[] = {9,10};               //2 LEDs
int ebeneSechs[] = {1,12,13};          //3 LEDs
int ebeneSieben[] = {14,15,16,17};  //4 LEDs

int alleEbenen[] = {ebeneEins,ebeneZwei,ebeneDrei,ebeneVier,ebeneFuenf,ebeneSechs,ebeneSieben}; //7 Ebenen

Die einzelnen Ebenen lassen sich super ansprechen, aber wenn ich alle Ebenen ansprechen will, passiert nichts.
geplant war, dass eine Schicht nach der anderen angeht und wieder aus.
Code davon:

for(int i=0; i < 7; i++) {
    digitalWrite(alleEbenen[i],HIGH);
    delay(250);
  }
  delay(1000);
  for(int i=7; i < 7; i--) {
    digitalWrite(alleEbenen[i],HIGH);
    delay(100);
  }

Meine Frage jetzt, würde es mit “alleEbene” so funktionieren, bzw wo ist da der Fehler?
Und wenn es so nicht gehen würde, wie könnte ich es alternativ machen?

LG Soltanius

Und wo ist der Schaltplan, wie du die LEDs vom Arduino aus ansteuerst?
Kann ja sein, das da schon der Fehler liegt.

Auf Grund der Fragmente kann man nichts komplettes aussagen.
Aber Du greifst ja nur auf die Teilarrays und nicht auf deren Elemente zu.

Gruß Tommy

An der verkablung ist nicht falsch, da dies schon durch eine Test Sequenz geprüft wurde, aber für dich, die positiven Led Beine sind mit den Pins verbunden, die auf der SKizze stehen, die negativen alle mit GND

So teste ich bei jedem Lauf am Anfang, ob alle Leds in der Richtigen Reihenfolge sind:

//LED test
  for(int i=0; i < 17; i++) {
    digitalWrite(LEDPins[i],HIGH);
    delay(600);
  }
  delay(1000);
  for(int i=0; i < 17; i++) {
    digitalWrite(LEDPins[i],LOW);
    delay(100);
  }

Pin 11 und 1 sind mit Absicht vertauscht, damit die Spitze mit einem PWM Pin besetzt ist.
In der ersten Skizze, hab ich verschrieben, hier nochmal die korrigierte.

Soltanius:
An der verkablung ist nicht falsch, da dies schon durch eine Test Sequenz geprüft wurde, aber für dich, die positiven Led Beine sind mit den Pins verbunden, die auf der SKizze stehen, die negativen alle mit GND

Ohne Vorwiderstände?

Gruß Tommy

Tommy56:
Auf Grund der Fragmente kann man nichts komplettes aussagen.
Aber Du greifst ja nur auf die Teilarrays und nicht auf deren Elemente zu.

Gruß Tommy

Achso, ich dachte, die Pins werden werden durch meine Bezeichnung ersetzt..

Gibt es denn eine andere Möglichkeit die Schichten nacheinander so einzuschalten?
Vielleicht die Pins der entsprechenden Schicht in Klammern zu setzten?

Oder muss ich von einer for Schleife weichen und jede Schicht nacheinander mit "digitalWrite" ansprechen?

Tommy56:
Ohne Vorwiderstände?

Gruß Tommy

Nein, an den roten und grünen Leds hab ich 220 Ohm Widerstände und an den blauen 330 Ohm.

Das ging aus Deiner Beschreibung nicht hervor. Ich würde auf Deine LED folgendermaßen zugreifen:

digitalWrite(alleEbenen[ebenenNummer][LedNummerInDerEbene]) = HIGH;

Du musst natürlich auch alle LED-Pins als Ausgang definieren. Das sieht man in Deinem Fragment nicht, ob Du das tust. Mit dem kompletten Sketch könnte man sich viele Rückfragen sparen.

Gruß Tommy

Es müsste

int* alleEbenen[] ={ebeneEins,ebeneZwei,ebeneDrei,ebeneVier,ebeneFuenf,ebeneSechs,ebeneSieben}; //7 Ebenen

heissen. Das hat aber noch den Nachteil, dass du nicht weisst, wie viele Elemente jede Ebene hat.

Mit digitalWrite kannst du jedenfalls nur einen einzelnen Pin ansprechen.

Vorschlag:

  • nimm die 0 als Endekennung, oder (wenn du Pin 0 verwenden willst) die 255
  • nimm byte statt int, um nicht ganz so verschwenderisch mit dem RAM umzugehen.
byte ebeneEins[] = {2,3, 0};                   //2 LEDs
byte ebeneZwei[] = {4, 0};                     //1 LED
byte ebeneDrei[] = {5,6, 0};                   //2 LEDs
byte ebeneVier[] = {7,8, 0};                   //2 LEDs
byte ebeneFuenf[] = {9,10, 0};               //2 LEDs
byte ebeneSechs[] = {1,12,13, 0};          //3 LEDs
byte ebeneSieben[] = {14,15,16,17, 0};  //4 LEDs

byte* alleEbenen[] = {ebeneEins,ebeneZwei,ebeneDrei,ebeneVier,ebeneFuenf,ebeneSechs,ebeneSieben}; //7 Ebenen


void setup() {
 for(int i=0; i < 7; i++) {
  byte* pin= alleEbenen[i] ;
  while (*pin != 0) {
    pinMode (*pin++, OUTPUT);
  }  
 }
}

loop() lasse ich für dich

Soltanius:
Nein, an den roten und grünen Leds hab ich 220 Ohm Widerstände und an den blauen 330 Ohm.

Eigentlich sollte es umgekehrt sein, da die blauen LED eine größere Durchlaßspannung haben und darum wenn man einen ähnlichen LED Strom will, Die Vorwiderstände kleiner sein müssen.

Grüße Uwe

wenn man einen ähnlichen LED Strom will, Die Vorwiderstände kleiner sein müssen

Vielleicht findet man die blauen Led nicht ganz so hässlich, wenn sie nicht so hell sind :wink:

Immerhin hat er zum Schaltung prüfen ja schon einen Test-Sketch. ( Sehr löblich, übrigens )

Tommy56:
Du musst natürlich auch alle LED-Pins als Ausgang definieren. Das sieht man in Deinem Fragment nicht, ob Du das tust. Mit dem kompletten Sketch könnte man sich viele Rückfragen sparen.

Hier einmal das komplette Programm bis jetzt:

byte LEDPins[] = {11,2,3,4,5,6,7,8,9,10,1,12,13,14,15,16,17}; //17 LEDs

//-------------------------------------------------------------erste Sequenz
byte redPins[] = {3,7,10,1,14,16,0}; //6 LEDs
byte greenPins[] = {2,5,8,12,17,0};  //5 LEDs
byte bluePins[] = {4,6,9,13,15,0};  // 5 LEDs
byte yellowPin[] = {11,0};
//-------------------------------------------------------------zweite Sequenz
byte ebeneEins[] = {2,3,0};  //2 LEDs
byte ebeneZwei[] = {4,0};   //1 LED
byte ebeneDrei[] = {5,6,0};  //2 LEDs
byte ebeneVier[] = {7,8,0};  //2 LEDs
byte ebeneFuenf[] = {9,10,0};  //2 LEDs
byte ebeneSechs[] = {1,12,13,0}; //3 LEDs
byte ebeneSieben[] = {14,15,16,17,0}; //4 LEDs
//-------------------------------------------------------------dritte Sequenz
byte rundum[] = {11,2,5,9,14,15,16,17,10,6,3,0};  //11 LEDs
//-------------------------------------------------------------vierte Sequenz
byte seiteEins[] = {11,2,5,9,14,0};    //5 LEDs
byte seiteZwei[] = {11,7,1,15,0};      //4 LEDs
byte seiteDrei[] = {11,4,12,0};        //3 LEDs
byte seiteVier[] = {11,8,13,16,0};     //4 LEDs
byte seiteFuenf[] = {11,3,6,10,17,0};  //5 LEDs

void setup() {
  allesAus();
  //LED test
  for(int i=0; i < 17; i++) {
    digitalWrite(LEDPins[i],HIGH);
    delay(300);
  }
  delay(1000);
  for(int i=0; i < 17; i++) {
    digitalWrite(LEDPins[i],LOW);
    delay(100);
  }
}

void loop() {
//-------------------------------------------------------------erste Sequenz
  digitalWrite(yellowPin,HIGH); 
  delay(50);  
  redPinsAn();
  greenPinsAn();
  bluePinsAn();
  delay(1000);
  allesAus();
//-------------------------------------------------------------zweite Sequenz
/*  for(int i=0; i < 3; i++) {
    ebenenObenNachUntenAn();
    delay(1000);
    ebenenObenNachUntenAus();
    delay(100);
  }
*/
//-------------------------------------------------------------dritte Sequenz
  for(int i=0; i < 5; i++){
    rundumAn();
    delay(1000);
    rundumAus();
    delay(100);
  }
//-------------------------------------------------------------vierte Sequenz
  seitenLinksNachRechtsAn();
  delay(1000);
  seitenLinksNachRechtsAus();
  delay(1000);  
}
//----------------------------------------------------------------------------------------------- Funktionen
void allesAus() {
  for(int i=0; i < 17; i++) {
    digitalWrite(LEDPins[i],LOW);
  }
}
//-------------------------------------------------------------erste Sequenz
void redPinsAn() {
  for(int i=0; i < 6; i++) {
    digitalWrite(redPins[i],HIGH);
    delay(80);
  }
}
void greenPinsAn() {
  for(int i=0; i < 5; i++) {
    digitalWrite(greenPins[i],HIGH);
    delay(80);
  }
}
void bluePinsAn() {
  for(int i=0; i < 5; i++) {
    digitalWrite(bluePins[i],HIGH);
    delay(80);
  }
} 
//-------------------------------------------------------------zweite Sequenz
void ebenenObenNachUntenAn() {
}
void ebenenObenNachUntenAus() {
}
//-------------------------------------------------------------dritte Sequenz
void rundumAn() {
  for(int i=0; i < 11; i++) {
      digitalWrite(rundum[i],HIGH);
      delay(100);
    }
}
void rundumAus() {
  for(int i=0; i < 11; i++){
    digitalWrite(rundum[i],LOW);
    delay(100);
  }
}
//-------------------------------------------------------------vierte Sequenz
void seitenLinksNachRechtsAn(){
  for(int i=0; i < 5; i++) {
    digitalWrite(seiteEins[i],HIGH);
    delay(80);
  }
  for(int i=0; i < 4; i++) {
    digitalWrite(seiteZwei[i],HIGH);
    delay(80);
  }
  for(int i=0; i < 3; i++) {
    digitalWrite(seiteDrei[i],HIGH);
    delay(80);
  }
  for(int i=0; i < 4; i++) {
    digitalWrite(seiteVier[i],HIGH);
    delay(80);
  }
  for(int i=0; i < 5; i++) {
    digitalWrite(seiteFuenf[i],HIGH);
    delay(80);
  }
}

void seitenLinksNachRechtsAus() {
  for(int i=0; i < 5; i++) {
    digitalWrite(seiteEins[i],LOW);
    delay(80);
  }
  for(int i=0; i < 4; i++) {
    digitalWrite(seiteZwei[i],LOW);
    delay(80);
  }
  for(int i=0; i < 3; i++) {
    digitalWrite(seiteDrei[i],LOW);
    delay(80);
  }
  for(int i=0; i < 4; i++) {
    digitalWrite(seiteVier[i],LOW);
    delay(80);
  }
  for(int i=0; i < 5; i++) {
    digitalWrite(seiteFuenf[i],LOW);
    delay(80);
  }
}

michael_x:
Es müsste

int* alleEbenen[] ={ebeneEins,ebeneZwei,ebeneDrei,ebeneVier,ebeneFuenf,ebeneSechs,ebeneSieben}; //7 Ebenen

heissen. Das hat aber noch den Nachteil, dass du nicht weisst, wie viele Elemente jede Ebene hat.

Mit digitalWrite kannst du jedenfalls nur einen einzelnen Pin ansprechen.

Vorschlag:

  • nimm die 0 als Endekennung, oder (wenn du Pin 0 verwenden willst) die 255
  • nimm byte statt int, um nicht ganz so verschwenderisch mit dem RAM umzugehen.
byte ebeneEins[] = {2,3, 0};                   //2 LEDs

byte ebeneZwei = {4, 0};                    //1 LED
byte ebeneDrei = {5,6, 0};                  //2 LEDs
byte ebeneVier = {7,8, 0};                  //2 LEDs
byte ebeneFuenf = {9,10, 0};              //2 LEDs
byte ebeneSechs = {1,12,13, 0};          //3 LEDs
byte ebeneSieben = {14,15,16,17, 0};  //4 LEDs

byte* alleEbenen = {ebeneEins,ebeneZwei,ebeneDrei,ebeneVier,ebeneFuenf,ebeneSechs,ebeneSieben}; //7 Ebenen

void setup() {
for(int i=0; i < 7; i++) {
  byte* pin= alleEbenen[i] ;
  while (*pin != 0) {
    pinMode (*pin++, OUTPUT);
  } 
}
}

Hab es mit byte geändert, danke für den Hinweis!
Mich verwirrt gerade nur stark das OUTPUT??

uwefed:
Eigentlich sollte es umgekehrt sein, da die blauen LED eine größere Durchlaßspannung haben und darum wenn man einen ähnlichen LED Strom will, Die Vorwiderstände kleiner sein müssen.

Grüße Uwe

Wollte das Blau nicht so gresslich hell haben und gehe sehr wahrscheinlich noch höher mit dem Widerstand.

michael_x:
Immerhin hat er zum Schaltung prüfen ja schon einen Test-Sketch. ( Sehr löblich, übrigens )

Danke! :slight_smile:

Mich verwirrt gerade nur stark das OUTPUT??

pinMode(Ledpin, OUTPUT);
sollte klar sein, oder ?

Hier ist pin ein Zeiger, bzw, der Anfang eines Arrays.

*pin ist der Wert an dieser Stelle des Arrays. ( Die Pin-Nummer )

pin++ setzt der Zeiger eins weiter ( nachdem der Wert aus dem Array gelesen wurde. )

Mich verwirrt, dass dein

  byte yellowPin[] = {3,4,5,0}; // oder ein ähnliches  Array
  digitalWrite(yellowPin,HIGH);

nicht angemeckert wird.

yellowPin als Pointer ist ja intern auch nur ein int und das passt. Deswegen stört sich der Compiler daran nicht.

So ist ja auch myFunction anstelle von myFunction() formal zulässig.

Evtl. wenn man alle Warnungen anmacht, könnte eine kommen.

Gruß Tommy

michael_x:
pinMode(Ledpin, OUTPUT);
sollte klar sein, oder ?

Hier ist pin ein Zeiger, bzw, der Anfang eines Arrays.

*pin ist der Wert an dieser Stelle des Arrays. ( Die Pin-Nummer )

pin++ setzt der Zeiger eins weiter ( nachdem der Wert aus dem Array gelesen wurde. )

Ja klar weiß ich, was "pinMode(Ledpin,OUTPUT);" bedeutet, aber inwiefern soll es mir weiterhelfen?
Ich muss die Pins nicht mehr als OUTPUT definieren?

Mein Ziel ist es, die LEDs Schichtweise anzuschalten.
Zuerst Ebene 1, dann 2 etc...

michael_x:
Mich verwirrt, dass dein

  byte yellowPin[] = {3,4,5,0}; // oder ein ähnliches  Array

digitalWrite(yellowPin,HIGH);



nicht angemeckert wird

Du hast dich stark verlesen, du meinst wahrscheinlich
"byte yellowPin = 11" und
" digitalWrite(yellowPin,HIGH);"( aus der ersten Sequenz)

Was genau verwirrt dich, bzw was sollte das Problem sein?

Tommy56:
Evtl. wenn man alle Warnungen anmacht, könnte eine kommen.

Kommt:

warning: invalid conversion from 'byte* {aka unsigned char*}' to 'uint8_t {aka unsigned char}' [-fpermissive]

digitalWrite(yellowPin,HIGH);

byte ebeneSechs[] = {1,12,13,0}; //3 LEDs

Müßte anstelle "1" nicht "11" stehen?

Pins sind Konstanten, könnten auch als solche gekennzeichnet werden.

byte LEDPins[] = {11,2,3,4,5,6,7,8,9,10,1,12,13,14,15,16,17}; //17 LEDs

Je nach verwendetem Arduino hängt an Pin 0 und 1 USB. Eine LED könnte stören.

Soltanius:
Ja klar weiß ich, was "pinMode(Ledpin,OUTPUT);" bedeutet, aber inwiefern soll es mir weiterhelfen?

Nach Reset sind alle Pins Eingänge. Diejenigen, die Ausgänge werden sollen, müssen als solche benannt werden.

agmue:
Müßte anstelle “1” nicht “11” stehen?

Nein, Pin 1 und 11 sind immer noch mit Absicht getauscht, damit die Spitze (11) auf einen PWM Pin ist.
ich hatte keine Lust mir noch ne gute PWM library zu besorgen und um Flash-Speicher sparen nahm ich dann doch die Hardware Pins.

agmue:
Nach Reset sind alle Pins Eingänge. Diejenigen, die Ausgänge werden sollen, müssen als solche benannt werden.

Das ist mir bewusst.

 for(int i=0; i < 17; i++) {
    pinMode(LEDPins[i],OUTPUT);
  }

Mach nichts anderes, als alle Pins auf Output setzten. (natürlich im void setup() )

Hi

Dort kannst Du den Kompiler dazu bringen, für Dich zu zählen.
statt i<17 kannst Du i<sizeof(LEDPins)/sizeof(LEDPins[0]) benutzen.
Dadurch errechnet der Kompiler beim Übersetzen, wie viele Einträge das Array hat und zählt dann auch genau so weit.
Wenn Du Mal mehr oder weniger Elemente einstellst, klappt’s dann immer noch ohne ‘magic numbers’ - also Zahlen im Code, Die ‘von egal wo her’ kommen.

Bei dem angesprochenem digitalWrite(yellowPin,HIGH); hätte ich auch eine Schleife erwartet aka

for (byte x=0;x<sizeof(yellpwPin)/sizeof(yellowPin[0]);x++){
   digitalWrite(yellowPin[x],HIGH);
}

Damit durchläufst Du alle Elemente von yellowPin und setzt diese Ausgänge auf HIGH.

MfG
Edit
Klammer AUF bei der FOR-Schleife nachgebessert

Soltanius:
Nein, Pin 1 und 11 sind immer noch mit Absicht getauscht, damit die Spitze (11) auf einen PWM Pin ist.

Dann ist in Deiner Skizze Pin 11 zweimal verwendet.

Soltanius:
Mach nichts anderes, als alle Pins auf Output setzten. (natürlich im void setup() )

Warum finde ich das dann nicht in Deinem Programm (#10)?

postmaster-ino:
Dort kannst Du den Kompiler dazu bringen, für Dich zu zählen.

Ein dazu passender Vorschlag:

const byte LEDPins[] = {11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 12, 13, 14, 15, 16, 17}; //17 LEDs

//-------------------------------------------------------------erste Sequenz
const byte redPins[] = {3, 7, 10, 1, 14, 16}; //6 LEDs
const byte greenPins[] = {2, 5, 8, 12, 17}; //5 LEDs
const byte bluePins[] = {4, 6, 9, 13, 15}; // 5 LEDs
const byte yellowPin[] = {11};
//-------------------------------------------------------------zweite Sequenz
const byte ebeneEins[] = {2, 3}; //2 LEDs
const byte ebeneZwei[] = {4};  //1 LED
const byte ebeneDrei[] = {5, 6}; //2 LEDs
const byte ebeneVier[] = {7, 8}; //2 LEDs
const byte ebeneFuenf[] = {9, 10}; //2 LEDs
const byte ebeneSechs[] = {11, 12, 13}; //3 LEDs
const byte ebeneSieben[] = {14, 15, 16, 17}; //4 LEDs
//-------------------------------------------------------------dritte Sequenz
const byte rundum[] = {11, 2, 5, 9, 14, 15, 16, 17, 10, 6, 3}; //11 LEDs
//-------------------------------------------------------------vierte Sequenz
const byte seiteEins[] = {11, 2, 5, 9, 14}; //5 LEDs
const byte seiteZwei[] = {11, 7, 1, 15};  //4 LEDs
const byte seiteDrei[] = {11, 4, 12};     //3 LEDs
const byte seiteVier[] = {11, 8, 13, 16}; //4 LEDs
const byte seiteFuenf[] = {11, 3, 6, 10, 17}; //5 LEDs

void setup() {
  allesAus();
  //LED test
  for (int i = 0; i < 17; i++) {
    pinMode(LEDPins[i], OUTPUT);
    digitalWrite(LEDPins[i], HIGH);
    delay(300);
  }
  delay(1000);
  for (int i = 0; i < 17; i++) {
    digitalWrite(LEDPins[i], LOW);
    delay(100);
  }
}

void loop() {
  //-------------------------------------------------------------erste Sequenz
  /*
    digitalWrite(yellowPin[0], HIGH);
    delay(50);
    redPinsAn();
    greenPinsAn();
    bluePinsAn();
    delay(1000);
    allesAus();
  */
  //-------------------------------------------------------------zweite Sequenz
  for (int i = 0; i < 3; i++) {
    ebenenObenNachUntenAn();
    delay(1000);
    ebenenObenNachUntenAus();
    delay(100);
  }
  //-------------------------------------------------------------dritte Sequenz
  /*
    for (int i = 0; i < 5; i++) {
    rundumAn();
    delay(1000);
    rundumAus();
    delay(100);
    }
    //-------------------------------------------------------------vierte Sequenz
    seitenLinksNachRechtsAn();
    delay(1000);
    seitenLinksNachRechtsAus();
  */
  delay(1000);
}
//----------------------------------------------------------------------------------------------- Funktionen
void allesAus() {
  for (int i = 0; i < 17; i++) {
    digitalWrite(LEDPins[i], LOW);
  }
}
//-------------------------------------------------------------erste Sequenz
void redPinsAn() {
  for (int i = 0; i < 6; i++) {
    digitalWrite(redPins[i], HIGH);
    delay(80);
  }
}
void greenPinsAn() {
  for (int i = 0; i < 5; i++) {
    digitalWrite(greenPins[i], HIGH);
    delay(80);
  }
}
void bluePinsAn() {
  for (int i = 0; i < 5; i++) {
    digitalWrite(bluePins[i], HIGH);
    delay(80);
  }
}
//-------------------------------------------------------------zweite Sequenz
void ausgabe(const byte* pin, const byte anzahl, const bool zustand, unsigned int zeit) {
  for (byte j = 0; j < anzahl; j++) {
    digitalWrite(pin[j], zustand);
  }
  delay(zeit);
}
void ebenenObenNachUntenAn() {
  ausgabe(ebeneEins, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneZwei, sizeof(ebeneZwei), HIGH, 100);
  ausgabe(ebeneDrei, sizeof(ebeneDrei), HIGH, 100);
  ausgabe(ebeneVier, sizeof(ebeneVier), HIGH, 100);
  ausgabe(ebeneFuenf, sizeof(ebeneFuenf), HIGH, 100);
  ausgabe(ebeneSechs, sizeof(ebeneSechs), HIGH, 100);
  ausgabe(ebeneSieben, sizeof(ebeneSieben), HIGH, 100);
}
void ebenenObenNachUntenAus() {
  ausgabe(ebeneEins, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneZwei, sizeof(ebeneZwei), LOW, 100);
  ausgabe(ebeneDrei, sizeof(ebeneDrei), LOW, 100);
  ausgabe(ebeneVier, sizeof(ebeneVier), LOW, 100);
  ausgabe(ebeneFuenf, sizeof(ebeneFuenf), LOW, 100);
  ausgabe(ebeneSechs, sizeof(ebeneSechs), LOW, 100);
  ausgabe(ebeneSieben, sizeof(ebeneSieben), LOW, 100);
}
//-------------------------------------------------------------dritte Sequenz
void rundumAn() {
  for (int i = 0; i < 11; i++) {
    digitalWrite(rundum[i], HIGH);
    delay(100);
  }
}
void rundumAus() {
  for (int i = 0; i < 11; i++) {
    digitalWrite(rundum[i], LOW);
    delay(100);
  }
}
//-------------------------------------------------------------vierte Sequenz
void seitenLinksNachRechtsAn() {
  for (int i = 0; i < 5; i++) {
    digitalWrite(seiteEins[i], HIGH);
    delay(80);
  }
  for (int i = 0; i < 4; i++) {
    digitalWrite(seiteZwei[i], HIGH);
    delay(80);
  }
  for (int i = 0; i < 3; i++) {
    digitalWrite(seiteDrei[i], HIGH);
    delay(80);
  }
  for (int i = 0; i < 4; i++) {
    digitalWrite(seiteVier[i], HIGH);
    delay(80);
  }
  for (int i = 0; i < 5; i++) {
    digitalWrite(seiteFuenf[i], HIGH);
    delay(80);
  }
}

void seitenLinksNachRechtsAus() {
  for (int i = 0; i < 5; i++) {
    digitalWrite(seiteEins[i], LOW);
    delay(80);
  }
  for (int i = 0; i < 4; i++) {
    digitalWrite(seiteZwei[i], LOW);
    delay(80);
  }
  for (int i = 0; i < 3; i++) {
    digitalWrite(seiteDrei[i], LOW);
    delay(80);
  }
  for (int i = 0; i < 4; i++) {
    digitalWrite(seiteVier[i], LOW);
    delay(80);
  }
  for (int i = 0; i < 5; i++) {
    digitalWrite(seiteFuenf[i], LOW);
    delay(80);
  }
}

EDIT 20181224: Feldnamen in den Funktionen ebenenObenNachUntenAn und ebenenObenNachUntenAus korrigiert.

postmaster-ino:
Hi

Dort kannst Du den Kompiler dazu bringen, für Dich zu zählen.
statt i<17 kannst Du i<sizeof(LEDPins)/sizeof(LEDPins[0]) benutzen.
Dadurch errechnet der Kompiler beim Übersetzen, wie viele Einträge das Array hat und zählt dann auch genau so weit.
Wenn Du Mal mehr oder weniger Elemente einstellst, klappt’s dann immer noch ohne ‘magic numbers’ - also Zahlen im Code, Die ‘von egal wo her’ kommen.

Bei dem angesprochenem digitalWrite(yellowPin,HIGH); hätte ich auch eine Schleife erwartet aka

for byte x=0;x<sizeof(yellpwPin)/sizeof(yellowPin[0]);x++){

digitalWrite(yellowPin,HIGH);
}



Damit durchläufst Du alle Elemente von yellowPin und setzt diese Ausgänge auf HIGH.

MfG

Vielen Dank für diese Vereinfachung!
Da ich nach meinem Wissen nach ersmals probiert habe wie es funktioniert und diese Methode noch nicht kannte, verwendete ich die andere.

agmue:
Dann ist in Deiner Skizze Pin 11 zweimal verwendet.

In einem darauf folgendem Beitrag, hab ich ein Bild von der korrigierten Skizze hochgeladen.

agmue:
Warum finde ich das dann nicht in Deinem Programm (#10)?

Ich weiß es ehrlich gesagt nicht… Ich frage mich, warum es nicht darin steht…
Das ist das Erste, was bei mir im void setup() steht ???

agmue:
Ein dazu passender Vorschlag:
[/quote

Bei dem unterem Teil:

void ebenenObenNachUntenAn() {

ausgabe(ebeneEins, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneZwei, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneDrei, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneVier, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneFuenf, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneSechs, sizeof(ebeneEins), HIGH, 100);
  ausgabe(ebeneSieben, sizeof(ebeneEins), HIGH, 100);
}
void ebenenObenNachUntenAus() {
  ausgabe(ebeneEins, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneZwei, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneDrei, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneVier, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneFuenf, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneSechs, sizeof(ebeneEins), LOW, 100);
  ausgabe(ebeneSieben, sizeof(ebeneEins), LOW, 100);
}



Hast du in jeder Zeile beim 2. Teil vergessen die richtige Ebene anzugeben.
Hab ich bei mir korrigiert.
Den Pin 11 hab ich wieder durch 1 ersetzt. 

Vielen Dank für diese Methode!
Wieder etwas dazu gelernt!

Hi

sizeof(ebeneEins)/sizeof(ebeneEins[0]) (Gesamt durch Einzel)

Dadurch kürzt sich die Länge der Einzel-Variable raus.
sizeof gibt den belegten Speicherplatz IN BYTE zurück.
Ein INT belegt z.B. 2 Byte Speicherplatz.
Um auf die Anzahl der Elemente zu kommen, teilt man deshalb den Gesamt-Speicherplatz durch den Einzel-Speicherplatz.

MfG