INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Schieberegister Strom
30.01.2020, 19:45
Beitrag #1
Schieberegister Strom
Hey Leute,

ich hätte mal eine Technische Frage zu meinem Projekt.

Ich verwende einen Arduino Micro und möchte damit 40 einzelne LED´s und 8x 7-Segment Anzeigen Ansteuern.
Ich Zählen von 60 abwärts und das ganze möchte ich an 4 Seiten gleichzeitig anzeigen. Jede LED hat eine bestimmte Nummer die über die Segmente im laufe des Programmes angezeigt wird.
Die LED´s schalte ich über Multiplexing, das passt soweit, das habe ich schon mal gemacht.

Das Programm habe ich soweit und es funktioiert auch.

Bei den Segmenten bin ich mir zwecks Strom nun aber ein bisschen unsicher.
Im Programm arbeite ich mit 2 Schieberegistern (74HC 595) die ich in Reihe schalte wodurch ich dann mit 16 Bit´s arbeite. (Ausgang 8 auf Eingang)
// int muster30[16] = {0,0,1,0,1,1,1,1,0,1,0,1,1,1,1,1,}; // ist bei mir dann eben die Zahl 30 die ich 4x darstellen möchte.

Nun zum eigentlichen Problem.
Die Schieberegister vertrag max ~50mA Last. Wenn ich aber bei der Zahl 8 alle LED´s der Segmentanzeige an mache wäre der Spaß schnell vorbei.
Weil die einzelnen LED´s der meisten Segmenten auch mit 20mA angegeben sind.
Daher würde ich nach den Schieberegistern noch 4x UDN 2981 schalten? Das macht Sinn bzw wäre das logisch? Big Grin
Für die 10er Stelle 2 und für die 1er Stellen 2, da die max Last bei denen ebenfalls bei 500mA liegt?

Bei dem UDN2981 bin ich mir nun aber nicht wirklich sicher was ich an Vcc anlegen soll bzw was bei dem Output dann rauskommt.
Bei 5V Vcc schalter er mit dann auch die 5V?




Wen es Interssiert, den Code dazu. Ja man könnte die Segmente auch pulsen lassen, aber soweit bin ich für mich noch nicht Big Grin

Code:
//Verwendete Variablen
int LED1; int LED2; int LED3; int LED4; int LED5; int LED6; int LED7; int LED8; int LED9; int LED10;
int LED11; int LED12; int LED13; int LED14; int LED15; int LED16; int LED17; int LED18; int LED19; int LED20;
int LED21; int LED22; int LED23; int LED24; int LED25; int LED26; int LED27; int LED28; int LED29; int LED30;
int LED31; int LED32; int LED33; int LED34; int LED35; int LED36; int LED37; int LED38; int LED39; int LED40;

int AusG_0=0; int AusG_1=1; int AusG_2=2; int AusG_3=3; int AusG_4=4; int AusG_5=5; int AusG_6=6;
int AusG_7=7; int AusG_8=8; int AusG_9=9; int AusG_10=10; int AusG_11=11; int AusG_12=12; int AusG_13=13;

int shiftPin_1 = 14;
int storePin_1 = 17;
int dataPin_1 = 15;
int shiftPin_2 = 16;
int InPut = 18;

int delayZeit;
int delayBlink;
int Taster;
int start;
int BStart;
int Stop;
int cd;

//Musterkombinationen der Segment Anezigen
int musterr[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,};
int muster[16] = {0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,};
int muster0[16] = {0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,};
int muster1[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,};
int muster2[16] = {0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,};
int muster3[16] = {0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,};
int muster4[16] = {0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,};
int muster5[16] = {0,0,0,0,0,0,0,0,0,1,1,0,1,1,0,1,};
int muster6[16] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,};
int muster7[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,};
int muster8[16] = {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,};
int muster9[16] = {0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,};
int muster10[16] = {0,0,0,0,0,1,1,0,0,1,0,1,1,1,1,1,};
                  
int muster11[16] = {0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,};
int muster12[16] = {0,0,0,0,0,1,1,0,0,0,1,1,1,0,1,1,};
int muster13[16] = {0,0,0,0,0,1,1,0,0,0,1,0,1,1,1,1,};
int muster14[16] = {0,0,0,0,0,1,1,0,0,1,1,0,0,1,1,0,};
int muster15[16] = {0,0,0,0,0,1,1,0,0,1,1,0,1,1,0,1,};
int muster16[16] = {0,0,0,0,0,1,1,0,0,1,1,1,1,1,0,1,};
int muster17[16] = {0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,};
int muster18[16] = {0,0,0,0,0,1,1,0,0,1,1,1,1,1,1,1,};
int muster19[16] = {0,0,0,0,0,1,1,0,0,1,1,0,1,1,1,1,};
int muster20[16] = {0,0,1,1,1,0,1,1,0,1,0,1,1,1,1,1,};
  
int muster21[16] = {0,0,1,1,1,0,1,1,0,0,0,0,0,1,1,0,};
int muster22[16] = {0,0,1,1,1,0,1,1,0,0,1,1,1,0,1,1,};
int muster23[16] = {0,0,1,1,1,0,1,1,0,0,1,0,1,1,1,1,};
int muster24[16] = {0,0,1,1,1,0,1,1,0,1,1,0,0,1,1,0,};
int muster25[16] = {0,0,1,1,1,0,1,1,0,1,1,0,1,1,0,1,};
int muster26[16] = {0,0,1,1,1,0,1,1,0,1,1,1,1,1,0,1,};
int muster27[16] = {0,0,1,1,1,0,1,1,0,0,0,0,0,1,1,1,};
int muster28[16] = {0,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1,};
int muster29[16] = {0,0,1,1,1,0,1,1,0,1,1,0,1,1,1,1,};

int muster30[16] = {0,0,1,0,1,1,1,1,0,1,0,1,1,1,1,1,};
int muster31[16] = {0,0,1,0,1,1,1,1,0,0,0,0,0,1,1,0,};
int muster32[16] = {0,0,1,0,1,1,1,1,0,0,1,1,1,0,1,1,};
int muster33[16] = {0,0,1,0,1,1,1,1,0,0,1,0,1,1,1,1,};
int muster34[16] = {0,0,1,0,1,1,1,1,0,1,1,0,0,1,1,0,};
int muster35[16] = {0,0,1,0,1,1,1,1,0,1,1,0,1,1,0,1,};
int muster36[16] = {0,0,1,0,1,1,1,1,0,1,1,1,1,1,0,1,};
int muster37[16] = {0,0,1,0,1,1,1,1,0,0,0,0,0,1,1,1,};
int muster38[16] = {0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,};
int muster39[16] = {0,0,1,0,1,1,1,1,0,1,1,0,1,1,1,1,};
  
int muster40[16] = {0,1,1,0,0,1,1,0,0,1,0,1,1,1,1,1,};
int muster41[16] = {0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,0,};
int muster42[16] = {0,1,1,0,0,1,1,0,0,0,1,1,1,0,1,1,};
int muster43[16] = {0,1,1,0,0,1,1,0,0,0,1,0,1,1,1,1,};
int muster44[16] = {0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,};
int muster45[16] = {0,1,1,0,0,1,1,0,0,1,1,0,1,1,0,1,};
int muster46[16] = {0,1,1,0,0,1,1,0,0,1,1,1,1,1,0,1,};
int muster47[16] = {0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,1,};
int muster48[16] = {0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,1,};
int muster49[16] = {0,1,1,0,0,1,1,0,0,1,1,0,1,1,1,1,};
  
int muster50[16] = {0,1,1,0,1,1,0,1,0,1,0,1,1,1,1,1,};
int muster51[16] = {0,1,1,0,1,1,0,1,0,0,0,0,0,1,1,0,};
int muster52[16] = {0,1,1,0,1,1,0,1,0,0,1,1,1,0,1,1,};
int muster53[16] = {0,1,1,0,1,1,0,1,0,0,1,0,1,1,1,1,};
int muster54[16] = {0,1,1,0,1,1,0,1,0,1,1,0,0,1,1,0,};
int muster55[16] = {0,1,1,0,1,1,0,1,0,1,1,0,1,1,0,1,};
int muster56[16] = {0,1,1,0,1,1,0,1,0,1,1,1,1,1,0,1,};
int muster57[16] = {0,1,1,0,1,1,0,1,0,0,0,0,0,1,1,1,};
int muster58[16] = {0,1,1,0,1,1,0,1,0,1,1,1,1,1,1,1,};
int muster59[16] = {0,1,1,0,1,1,0,1,0,1,1,0,1,1,1,1,};
int muster60[16] = {0,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,};
  
void setup()
{
  
  //pinMode Belegung
  pinMode(shiftPin_1, OUTPUT);
  pinMode(storePin_1, OUTPUT);
  pinMode(dataPin_1, OUTPUT);
  pinMode(shiftPin_2, OUTPUT);
  pinMode(InPut, INPUT);
  
  pinMode(AusG_2, OUTPUT);
  pinMode(AusG_3, OUTPUT);
  pinMode(AusG_4, OUTPUT);
  pinMode(AusG_5, OUTPUT);
  pinMode(AusG_6, OUTPUT);
  pinMode(AusG_7, OUTPUT);
  pinMode(AusG_8, OUTPUT);
  pinMode(AusG_9, OUTPUT);
  pinMode(AusG_10, OUTPUT);
  pinMode(AusG_11, OUTPUT);
  pinMode(AusG_12, OUTPUT);
  pinMode(AusG_13, OUTPUT);
  pinMode(AusG_1, OUTPUT);
  pinMode(AusG_0, OUTPUT);
  
  //Standart LOW/HIGH Ausgänge damit keine LED leuchtet
  digitalWrite(AusG_2,LOW); digitalWrite(AusG_3,LOW); digitalWrite(AusG_0,LOW); digitalWrite(AusG_1,LOW);
    
  digitalWrite(AusG_6,HIGH); digitalWrite(AusG_7,HIGH); digitalWrite(AusG_8,HIGH); digitalWrite(AusG_9,HIGH);
  digitalWrite(AusG_10,HIGH); digitalWrite(AusG_11,HIGH); digitalWrite(AusG_12,HIGH); digitalWrite(AusG_13,HIGH);
  digitalWrite(AusG_5,HIGH); digitalWrite(AusG_4,HIGH);
  
  //Festgelegte Delayzeiten
  delayZeit=(300);
  delayBlink=(500);
  
  //Programmbeginn mit zwei mal - -  
  digitalWrite(storePin_1, LOW);
  for( int i=0; i<16; i++)
  {
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster[i]); digitalWrite(shiftPin_1, HIGH);  
  }
  digitalWrite(storePin_1, HIGH);
  

  Taster=digitalRead(InPut);
}
////////////////LOOP//////////////
void loop()
{
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED1 == 0 && start == 1)
  {  
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster31[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
      
  
    
    digitalWrite(AusG_0,HIGH); digitalWrite(AusG_4,LOW);
    delay(delayZeit);
    digitalWrite(AusG_0,LOW); digitalWrite(AusG_4,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED1 = 1;
   digitalWrite(AusG_0,HIGH); digitalWrite(AusG_4,LOW);
   delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);  
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED2 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster15[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    

    
    digitalWrite(AusG_2,HIGH); digitalWrite(AusG_8,LOW);
    delay(delayZeit);
    digitalWrite(AusG_2,LOW); digitalWrite(AusG_8,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED2 = 1;
   digitalWrite(AusG_2,HIGH); digitalWrite(AusG_8,LOW);
   delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  

  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED3 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster38[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_0,HIGH); digitalWrite(AusG_11,LOW);
    delay(delayZeit);
    digitalWrite(AusG_0,LOW); digitalWrite(AusG_11,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED3 = 1;
   digitalWrite(AusG_0,HIGH); digitalWrite(AusG_11,LOW);
   delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }


  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED4 == 0 && start == 1)
  {  
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster9[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
  
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_12,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_12,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED4 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_12,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED5 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster33[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    

    digitalWrite(AusG_0,HIGH); digitalWrite(AusG_6,LOW);
    delay(delayZeit);
    digitalWrite(AusG_0,LOW); digitalWrite(AusG_6,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED5 = 1;
   digitalWrite(AusG_0,HIGH); digitalWrite(AusG_6,LOW);
   delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED6 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster7[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_10,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_10,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED6 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_10,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }

  

  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED7 == 0 && start == 1)
  {  
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster39[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
        
    
    digitalWrite(AusG_0,HIGH); digitalWrite(AusG_12,LOW);
    delay(delayZeit);
    digitalWrite(AusG_0,LOW); digitalWrite(AusG_12,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED7 = 1;
   digitalWrite(AusG_0,HIGH); digitalWrite(AusG_12,LOW);
   delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED8 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster1[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_4,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_4,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED8 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_4,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED9 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster13[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_2,HIGH); digitalWrite(AusG_6,LOW);
    delay(delayZeit);
    digitalWrite(AusG_2,LOW); digitalWrite(AusG_6,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED9 = 1;
   digitalWrite(AusG_2,HIGH); digitalWrite(AusG_6,LOW);
   delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }

  

  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED10 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster27[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_1,HIGH); digitalWrite(AusG_10,LOW);
    delay(delayZeit);
    digitalWrite(AusG_1,LOW); digitalWrite(AusG_10,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED10 = 1;
   digitalWrite(AusG_1,HIGH); digitalWrite(AusG_10,LOW);
   delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }  

  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED11 == 0 && start == 1)
  {  
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster8[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
      
  
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_11,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_11,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED11 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_11,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);  
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED12 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster29[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    

    
    digitalWrite(AusG_1,HIGH); digitalWrite(AusG_12,LOW);
    delay(delayZeit);
    digitalWrite(AusG_1,LOW); digitalWrite(AusG_12,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED12 = 1;
   digitalWrite(AusG_1,HIGH); digitalWrite(AusG_12,LOW);
   delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  

  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED13 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster40[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_0,HIGH); digitalWrite(AusG_13,LOW);
    delay(delayZeit);
    digitalWrite(AusG_0,LOW); digitalWrite(AusG_13,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED13 = 1;
   digitalWrite(AusG_0,HIGH); digitalWrite(AusG_13,LOW);
   delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }


  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED14 == 0 && start == 1)
  {  
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster31[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
  
    
    digitalWrite(AusG_0,HIGH); digitalWrite(AusG_4,LOW);
    delay(delayZeit);
    digitalWrite(AusG_0,LOW); digitalWrite(AusG_4,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED14 = 1;
   digitalWrite(AusG_0,HIGH); digitalWrite(AusG_4,LOW);
   delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);
   digitalWrite(AusG_0,LOW); delay(delayBlink); digitalWrite(AusG_0,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED15 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster14[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    

    digitalWrite(AusG_2,HIGH); digitalWrite(AusG_7,LOW);
    delay(delayZeit);
    digitalWrite(AusG_2,LOW); digitalWrite(AusG_7,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED15 = 1;
   digitalWrite(AusG_2,HIGH); digitalWrite(AusG_7,LOW);
   delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   digitalWrite(AusG_2,LOW); delay(delayBlink); digitalWrite(AusG_2,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED16 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster6[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_9,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_9,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED16 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_9,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }

  

  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED17 == 0 && start == 1)
  {  
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster28[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
        
    
    digitalWrite(AusG_1,HIGH); digitalWrite(AusG_11,LOW);
    delay(delayZeit);
    digitalWrite(AusG_1,LOW); digitalWrite(AusG_11,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED17 = 1;
   digitalWrite(AusG_1,HIGH); digitalWrite(AusG_11,LOW);
   delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0)
  {
    start = 1; BStart = 1;
  }
  if(LED18 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster10[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_13,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_13,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED18 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_13,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);  
   cd = 1;
  }  
  }
  
  
  
  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED19 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster21[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_1,HIGH); digitalWrite(AusG_4,LOW);
    delay(delayZeit);
    digitalWrite(AusG_1,LOW); digitalWrite(AusG_4,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED19 = 1;
   digitalWrite(AusG_1,HIGH); digitalWrite(AusG_4,LOW);
   delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   digitalWrite(AusG_1,LOW); delay(delayBlink); digitalWrite(AusG_1,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }

  

  Taster=digitalRead(InPut);
  if(Taster == HIGH && cd ==0 && BStart == 0)
  {
    start = 1; BStart = 1;
  }
  if(LED20 == 0 && start == 1)
  {      
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster4[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    
    digitalWrite(AusG_3,HIGH); digitalWrite(AusG_7,LOW);
    delay(delayZeit);
    digitalWrite(AusG_3,LOW); digitalWrite(AusG_7,HIGH);
    
    if(BStart == 1 && Taster == LOW)
  {
    delayZeit = delayZeit + 80;
  }
  if(delayZeit >= 1000)
  {
   start = 0; LED20 = 1;
   digitalWrite(AusG_3,HIGH); digitalWrite(AusG_7,LOW);
   delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   digitalWrite(AusG_3,LOW); delay(delayBlink); digitalWrite(AusG_3,HIGH); delay(delayBlink);
   cd = 1;
  }  
  }
  
  
  
  
  
  
  if(cd==1 && start == 0)
{
  
    delay (5000);
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster60[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
        digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster59[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
        digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster58[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster57[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster56[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster55[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster54[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster53[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster52[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster51[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster50[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    
        
    
     digitalWrite(AusG_2,LOW);
     digitalWrite(AusG_3,LOW);
     digitalWrite(AusG_0,LOW);
     digitalWrite(AusG_1,LOW);
    
     digitalWrite(AusG_6,HIGH);
     digitalWrite(AusG_7,HIGH);
     digitalWrite(AusG_8,HIGH);
     digitalWrite(AusG_9,HIGH);
     digitalWrite(AusG_10,HIGH);
     digitalWrite(AusG_11,HIGH);
     digitalWrite(AusG_12,HIGH);
     digitalWrite(AusG_13,HIGH);
     digitalWrite(AusG_5,HIGH);
     digitalWrite(AusG_4,HIGH);
    
    
    
    
    delay(1000);
    
    
            digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster49[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster48[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster47[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster46[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster45[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster44[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster43[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster42[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster41[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster40[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster39[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster38[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster37[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster36[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster35[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster34[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster33[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster32[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster31[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster30[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster29[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster28[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster27[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster26[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster25[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster24[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster23[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster22[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster21[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster20[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster19[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster18[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster17[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster16[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster15[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster14[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster13[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster12[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster11[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster10[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster9[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster8[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster7[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster6[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster5[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster4[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster3[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster2[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster1[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);

    delay(1000);
    
    
    digitalWrite(storePin_1, LOW);
    for( int i=0; i<16; i++)
  {  
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster0[i]); digitalWrite(shiftPin_1, HIGH);
  }  
    digitalWrite(storePin_1, HIGH);
    
    delay(3000);
    
    digitalWrite(storePin_1, LOW);
  for( int i=0; i<16; i++)
  {
    digitalWrite(shiftPin_1, LOW); digitalWrite(dataPin_1, muster[i]); digitalWrite(shiftPin_1, HIGH);  
  }
  digitalWrite(storePin_1, HIGH);  
  
     digitalWrite(AusG_2,LOW);
     digitalWrite(AusG_3,LOW);
     digitalWrite(AusG_0,LOW);
     digitalWrite(AusG_1,LOW);
    
     digitalWrite(AusG_6,HIGH);
     digitalWrite(AusG_7,HIGH);
     digitalWrite(AusG_8,HIGH);
     digitalWrite(AusG_9,HIGH);
     digitalWrite(AusG_10,HIGH);
     digitalWrite(AusG_11,HIGH);
     digitalWrite(AusG_12,HIGH);
     digitalWrite(AusG_13,HIGH);
     digitalWrite(AusG_5,HIGH);
     digitalWrite(AusG_4,HIGH);
    
  cd = 0;
  delayZeit=(300);
  delay(2000);
  BStart = 0;
  }
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 13:16 (Dieser Beitrag wurde zuletzt bearbeitet: 31.01.2020 13:19 von hotsystems.)
Beitrag #2
RE: Schieberegister Strom
Aus meiner Sicht kannst du den UDN2981 für dein Vorhaben verwenden.
Wenn du den mit 5Volt speist, werden dann auch die 5V am Ausgang rauskommen, abzüglich der Verluste über die Kollektor-Emitter-Strecke. Und ja, der maximale Strom beträgt hier 0,5A. Da musst du genau ausrechnen, ob das für deine Anwendung reicht.

Da ich deinen Aufbau nicht genau verstanden habe, ist diese Aussage evtl. nur bedingt richtig. Mit einem Schaltbild wäre es def. einfacher darauf zu antworten.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 15:01
Beitrag #3
RE: Schieberegister Strom
(30.01.2020 19:45)Bau3r schrieb:  Das Programm habe ich soweit und es funktioiert auch.
Du solltest aber mal dringend über deine sehr großzügige Verwendung von 'int' nachdenken. Dein Ram-Verbrauch ist da gigantisch, und damit wirst Du dir über kurz oder lang Stabilitätsprobleme einhandeln. Die IDE warnt dich ja bereits davor.

Gruß, Franz-Peter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 17:19
Beitrag #4
RE: Schieberegister Strom
Hier eine grobe Zeichnung wie ich es meinte. (Die Widerstände und die register eingänge hab ich jetzt mal weg gelassen).


Jaaa der Skatch ist sehr groß. Nach dem Upload sind 98% des Speichers belegt.
Das wäre meine nächste Frage, wie sich die Stabilitätsprobleme äußert bzw ab wann hat man die hat. Ab 90%=?

Die Menge der "int" liegt daran, da ich für jede der 40 LED´s ein Merker brauche, womit diese nicht mehr angesteuert wird wenn sie schon einmal permanent leuchtete.
Zuvor hatte ich auch weniger "int´s" bezüglich meinen "mustern" 1-60.
Erst hatte ich die register als 8 bit einzeln angesteuert um die Zahlen anzuzeigen, doch dann kam ich auf 112% Speicher verbrauch was somit nicht ging.

Wenn ihr eine andere Idee habt wie ich z.b. von 60 herunter zähle und gleichzeitg die Nummer der LED anzeigen kann, dann gerne her damit Big Grin


Zum verständnis. Die 40 LED´s blinken "schnell" (300ms) nacheinander. Wenn man man den start Taster erneut Drück wird das blinken immer langsamer bis eine LED an bleibt. Während des blinkens sollen die Segmente die Nummer der jeweiligen LED anzeigen. Danach sollen die Segmente von 60 auf 0 herunter zählen und die LED geht wieder aus . Beim nächsten start blinken wieder alle LED´s bis auf die vorherige. Das Programm/ Spiel ist dann vorbei, wenn all LED`s mal an waren.

Laut TinkerCAD funktioniert das auch so, aber nur mit max 20LED´s Big Grin
Wenn ich das Original Programm einspiele passiert nach dem Initialisieren nichts mehr...


Angehängte Datei(en) Thumbnail(s)
   
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 17:22
Beitrag #5
RE: Schieberegister Strom
Merker für 40 LED sind 40 Bit = 5 Byte zu 40 int = 80 Byte.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 17:35 (Dieser Beitrag wurde zuletzt bearbeitet: 31.01.2020 17:41 von MicroBahner.)
Beitrag #6
RE: Schieberegister Strom
(31.01.2020 17:19)Bau3r schrieb:  Die Menge der "int" liegt daran, da ich für jede der 40 LED´s ein Merker brauche, womit diese nicht mehr angesteuert wird wenn sie schon einmal permanent leuchtete.
Ob das so notwendig ist, habe ich mir jetzt garnicht angeschaut. Es geht in erster Linie mal nicht um die Menge der Variablen, sondern um den Datentyp 'int'. Der belegt im Speicher 2 Byte ( 16Bit), von denen Du aber nur ein einzelnes Bit verwendest.
Du kannst in einem ersten Schritt fast alle deiner Variabelen als 'byte' deklarieren. Damit sparst Du schonmal fast die Hälfte an RAM ein. Nur die Variablen, in denen Du Werte >255 speichern willst, musst Du als int deklarieren ( auf den ersten Blick waren das nur 2 ).

Und auf den ersten Blick fallen da viele Abschnitte auf, die immer wieder ähnlich sind - da liesse sich sicher viel mit Funktionen machen.

Einfach so linear runterprogrammieren macht den Speicher schnell voll ( und wäre mir auch ehrlich gesagt viel zu viel Tipperei - auch mit copy/paste und Anpassen ).

Instabil wird das Programm wenn das RAM zu voll wird. Das ist nicht nur der Platz für deine globalen Variablen - Der Prozessor braucht da auch Platz um zu arbeiten. Wenn das wegen 'zu voll' instabil wird, kann alles möglich passieren - vom unerklärlichen Ändern von Variablen bis zum Absturz.

So wie ich das sehe, hast Du dringenden Lernbedarf bei Datentypen und dem Einsatz von Funktionen. Ohne dieses Wissen machen so komplexe Projekte keinen Sinn.

Gruß, Franz-Peter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 17:56
Beitrag #7
RE: Schieberegister Strom
Also das verwenden von byte hat mir schonmal 31% mehr Speicher gegeben Big Grin -> 67% nun
Bei 83% des dynamischen Speichers wird mir immer noch eine warnung angezeigt. wo sollte der ~ liegen?

Jaaa, es ist fast alles das gleiche, außer die bestimmten Ausgänge die ich schalte. Aber ehrlich gesagt fällt mir da keine genau Funktion dazu ein.
Wie gesagt, ich bin erst mal soweit zufrieden, dass ich das schonmal geschafft habt Big Grin

Wenn mir jemand sagt, wie ich die Muster 1-60 mit delay nacheinander in einer Funktion anzeigen kann, wäre mir auch schon viel geholfen, auch für die Zukunft
Ich könnte auch wieder zu der 2x 8Bit variante zurück wenn das einfacher wäre.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2020, 18:25 (Dieser Beitrag wurde zuletzt bearbeitet: 31.01.2020 18:26 von Tommy56.)
Beitrag #8
RE: Schieberegister Strom
Meinen Vorschlag mit den 40 Bit = 5 Byte ignorierst Du erst mal.
Du kannst auch Deine Muster viel speichersparender und alle in einem Array unterbringen:
Code:
// Dein Code
int muster[16] = {0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,};
int muster0[16] = {0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,};
int muster1[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,};

// besser
unsigned int muster = {
                        0B0010000000100000,
                        0B0000000001011111,
                        0B0000000000000110,
                        ...
                      };
Dann kannst Du mit muster[i] auf das ganze Muster mit i = 0 bis Anzahl -1 zugreifen und mit bitRead auf das Bit darin.
Also nochmal von 60 * 16 * 2 = 1920 Bytes auf 60 * 2 = 120 Bytes, also 1/16

Durch den Arrayzugriff kannst Du dann auch den Code stark vereinfachen.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Schieberegister 74HC595 an SPI Mathias 0 1.775 25.07.2018 20:01
Letzter Beitrag: Mathias
  schieberegister mit 2 Datapins ? ardufan01 15 3.925 27.03.2018 11:55
Letzter Beitrag: Tommy56
  Parallel Load Serial Out Schieberegister Laura 4 3.186 11.12.2016 03:33
Letzter Beitrag: Bitklopfer
  Arduino in Lampe mit Lichtschalter - woher bekomm ich Strom? aggro600 19 7.903 19.08.2016 11:30
Letzter Beitrag: ardu_arne
  LED Matrix Multiplexing mit Schieberegister MrFuzzy 5 4.982 08.04.2016 16:23
Letzter Beitrag: MrFuzzy
  Schieberegister undefinierter Zustand BluCut 7 4.053 14.10.2015 09:16
Letzter Beitrag: BluCut
  [gelöst] Kann der Strom zu fremden GND abließen? flodo 12 4.412 10.09.2015 11:07
Letzter Beitrag: workwind
  Frage zu Strom JoSiGB 0 1.698 14.11.2014 09:44
Letzter Beitrag: JoSiGB
Question Umschaltbare Strom-/Spannungsquelle gesucht fobi 0 1.901 22.07.2014 01:16
Letzter Beitrag: fobi
  Strom sparen - VCC, RAW und Spannungsregler itsy 2 2.465 26.06.2014 19:20
Letzter Beitrag: itsy

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste