Pause im Interrupt

[Michael L. (strompaedagoge)]

Hallo

ich habe einen Interrupt der ein laufendes Programm unterbrechen soll, 
eine Funktion aufrufen soll und danach wieder ganz normal im 
Programmcode weiter gehen soll. Funktioniert auch alles soweit.

Jetzt soll als optische Ausgabe beim Auslösen des Interrupts auch noch 
eine LED 3x blinken.

Da komme ich nicht weiter:

-delay und millis funktionieren im Interrupt nicht
-timer nutz auch einen Interrupt zur Unterbrechung, was auch nicht 
zielführend war.

Hat jemand eine Idee womit ich eine einfache kurze Pause zwischen dem 
wechseln des Status der LED realisieren kann?

MfG

[Max M. (jens2001)]

Michael L. schrieb:
> Jetzt soll als optische Ausgabe beim Auslösen des Interrupts auch noch
> eine LED 3x blinken.

In der ISR ein Flag setzen und die LED in der Loop blinken lassen.

[Falk B. (falk)]

@ Michael L. (strompaedagoge)

>Hat jemand eine Idee womit ich eine einfache kurze Pause zwischen dem
>wechseln des Status der LED realisieren kann?

Mit einer Statemachine

[Lurchi (Gast)]

Delay oder ähnliches sollte in einer ISR schon noch funktionieren, ist 
aber problematisch. Normal sollte eine ISR nicht so lange dauern, dass 
man da sichtbares Blinken von LEDs hinbekommt. Möglich wäre es ggf. in 
der ISR einen Timer zu starten, so dass der dann per PWM das Blinken 
erzeugt. Eine Timer ISR könnte den Blinker dann Abstellen, wenn er 
fertig ist.

Der erste Interrupts ist dann aber in der Regel fertig bevor die LED das 
erste mal aus geht.

[LostInMusic (Gast)]

>Jetzt soll als optische Ausgabe beim Auslösen des Interrupts auch noch
>eine LED 3x blinken.

Ich würde die LED schlicht in der ISR für einen oder sehr wenige 
Taktzyklen ein- und dann wieder ausschalten. Nicht geizen mit dem 
LED-Strom - dann kann man ihr Aufblitzen mit dem Auge problemlos 
wahrnehmen (sofern nicht gerade das volle Licht der Frühherbstsonne 
drauffällt).

[Schlumpf (Gast)]

Wenn es tatsächlich gewünscht ist, dass der Controller während der 
LED-Blinkerei "tot" ist, dann kannst du auch einfach eine Variable in 
einer Schleife hoch zählen und damit einen "delay" erzeugen.
Nicht gerade elegant, aber sehr simpel und wenn der Controller in der 
Zeit eh nichts Anderes zu tun hat, dann kannst ihn auch einfach zählen 
lassen.

Also:

LED an
Zählschleife
LED aus
Zählschleife
LED an

usw...

[fehlerteufel (Gast)]

Michael L. schrieb:
> -delay und millis funktionieren im Interrupt nicht
> -timer nutz auch einen Interrupt zur Unterbrechung, was auch nicht
> zielführend war.

Wenn das alles nicht geht, geht der Rest auch nicht.

[Icke ®. (49636b65)]

Michael L. schrieb:
> Hat jemand eine Idee womit ich eine einfache kurze Pause zwischen dem
> wechseln des Status der LED realisieren kann?

Ordentlichen Programmierstil angewöhnen. Die einzig sinnvollen 
Vorschläge:

Max M. schrieb:
> In der ISR ein Flag setzen und die LED in der Loop blinken lassen.

Falk B. schrieb:
> Mit einer Statemachine

Eine ISR sollte so kurz wie möglich sein und nur das allernotwendigste 
eledigen. Darin irgendwelche Verzögerungen einzubauen, ist geradezu 
widersinnig.

[Thomas F. (igel)]

Michael L. schrieb:
> Jetzt soll als optische Ausgabe beim Auslösen des Interrupts auch noch
> eine LED 3x blinken.
>
> Da komme ich nicht weiter:
>
> -delay und millis funktionieren im Interrupt nicht
> -timer nutz auch einen Interrupt zur Unterbrechung, was auch nicht
> zielführend war.


Und hier noch eine puristische Lösung für Sparfüchse:

Eine Variable Typ Byte - in ASM wahlweise ein Register oder RAM-Zelle - 
wird beim ersten "Auslösen" mit 0x01 geladen. Im Timer-IRQ zählt man 
diese hoch. Bit 5 wird als Blinksignal an einem Port ausgegeben. Bit 6 
und 7 zählen die Anzahl Blinkies hoch. Läuft die Variable über (255->0) 
wird das Blinken deaktiviert.

[Einer K. (Gast)]

Lurchi schrieb:
> Delay oder ähnliches sollte in einer ISR schon noch funktionieren, ist
> aber problematisch

Ich entnehme der Frage, dass Arduino gemeint ist.
Und da tuts delay() und millis() eben NICHT in einer ISR.
(zumindest nicht ohne besondere Vorkehrungen)
Denn sie benötigen selber die Timer0 ISR für ihre Funktion.

[Michael L. (strompaedagoge)]

Guten Morgen,
Ja es ist der Arduino gemeint.

Mir ist da noch eine Idee gekommen. Leider happert es etwas an der 
Umsätzung.

Ich setzte einfach wärend des Interrups eine Variable b auf 1. In der 
Loop schleiße frage ich diese einfach ab und wenn der Wert 1 ist startet 
die Funktion blinken. Funktioniert auch, aber nur einmal. Setze ich die 
Variable b wieder auf 0 danach, blinkt die LED nicht mehr sondern wird 
nur von dem Interrupt an oder aus geschaltet, je nach vorherigem 
Zustand. Warum ist das so?

[Einer K. (Gast)]

Michael L. schrieb:
> Warum ist das so?
Hmm....

Wahrscheinlich hast du einen endlichen Automaten gebaut, oder willst 
einen bauen, aber hast noch Probleme mit den Zustandsübergängen.

Hilfreich:
1. Zustände klar benennen.
2. Übergänge eindeutig definieren.

[Eric B. (beric)]

Michael L. schrieb:
> Warum ist das so?

Weil dein Code, den wir nicht kennen, einen Bug hat.

[Thomas E. (thomase)]

Michael L. schrieb:
> Mir ist da noch eine Idee gekommen. Leider happert es etwas an der
> Umsätzung.

Deine Idee taugt auch nichts.

Was willst du?
Du willst dreimal Blinken mit einem Takt von 500ms. Halbe Sekunde ein, 
halbe Sekunde aus.

Was brauchst du dafür?
Irgendwas, was dir eine halbe Sekunde macht.

Was hast du?
Deine Millis. Ein Zähler, der jede Millisekunde um 1 erhöht wird.

Reicht das?
Ja.

Wie macht man aus den Millis eine halbe Sekunde?
Weißt du, was ein Modulo ist?
Das ist der Rest einer ganzzahligen Division.
7/2 = 3, Rest 1

643/500 = 1, Rest 143
1000/500 = 2 Rest 0
1500/500 = 3 Rest 0

Wann sind immer 500(ms) um?
Genau, wenn der Rest 0 ist.

Du willst 3 Mal blinken. Genau genommen ist das 6 Mal. 3 Mal ein, 3 Mal 
aus.

Du setzt eine Variable 'blink' in deiner ISR also auf 6.

In der Loop fragst du die Millis ab, ob der Rest gerade 0 ist und 
solange deine Variable nicht 0 ist, wird geblinkt.

if(blink != 0)
{
  if((Millis % 500) == 0)
  {
    TOGGLE_LED;
    blink = blink - 1;
  } 
}

Kannst es auch c-typisch so schreiben:

if(blink)
{
  if(!(Millis % 500))  
  {
    TOGGLE_LED;
    blink--;
  }
}

Hat beim ersten Blinken noch einen kleinen Schönheitsfehler, aber das 
stört erstmal keinen großen Geist.

Edit: Zweimal auf der Tastatur von % nach & gewurstet.

[Einer K. (Gast)]

Hmm...

Ich habe da ein Beispiel für Taster und blinken in der Schublade, 
befürchte aber, dass das gnadenlos Oversized ist.
Und für den Anfang auch schwer zu verstehen......

Aber was solls..... Siehe Anhang .....
(auch wenn ich mich damit gnadenlos blamiere)
Im Vordergrund steht bei dem Beispiel nicht die effiziente 
Tasterabfrage, sondern Nebenläufigkeit, bzw. kooperatives Multitasking. 
Und eine einfache Form der Schrittkette/Ablaufsteuereung.

[Thomas E. (thomase)]

Thomas E. schrieb:
> In der Loop fragst du die Millis ab, ob der Rest gerade 0 ist und
> solange deine Variable nicht 0 ist, wird geblinkt.

Du mußt natürlich sicherstellen, daß Millis vor jeder erneuten Abfrage 
auch weitergezählt wurde. Sonst macht der Controller das Blinken locker 
in derselben Millisekunde und du siehst gar nichts.

Damit bist du dann in einer getakteten Schleife. Die braucht man aber 
sowieso für alles mögliche.

Z.B.

unsigned long MillisLast = 0;
Loop
{
  if(Millis != MillisLast)
  {
    MillisLast = Millis;

    //Hier kommt der Blinker hin
  }
}

Da gibt es noch diverse andere Möglichkeiten. Dies sei mal eine davon.

[Max M. (jens2001)]

Michael L. schrieb:
> Mir ist da noch eine Idee gekommen. Leider happert es etwas an der
> Umsätzung.
>
> Ich setzte einfach wärend des Interrups eine Variable b auf 1. In der
> Loop schleiße frage ich diese einfach ab und wenn der Wert 1 ist startet
> die Funktion blinken

Wenn du mal die ERSTE ANTWORT auf deine Frage gelesen hättest....

Max M. schrieb:
> In der ISR ein Flag setzen und die LED in der Loop blinken lassen.

[Michael L. (strompaedagoge)]

// Example of driving a stepper motor using
// an Adruino and the AccelStepper library 
// via the a4899 stepper motor controller 


#include <AccelStepper.h>
#include <stdint.h>

//---------------------------------------------------------------------------------------------

//Einstellungen anpassen
float Quellspannung = 5.0;


// Versuchsaufbau 
//  _        -> vorwärts
//  M| \\\\\\\\Schlitten\\\\\
//  -
//Endschalter             Endschalter
//links Pin D2            rechts Pin D3
//
//Drehung rechts -> vorwärts
//Drehung links -> rückwärts

//---------------------------------------------------------------------------------------------

// Pin Belegung Schrittmotor
const uint8_t stepPin = 10;
const uint8_t dirPin = 11;
const uint8_t disablePin = 13;
const int buttonPin1 = 4;
const int buttonPin2 = 5;
const int buttonPin3 = 6;
const int led1Pin = 8;
const int led2Pin = 9;

// Pin Belegung Spannungsteiler
int AnalogPin1 = A1;
int AnalogPin2 = A2;

//Variablen Spannungsteiler 
int R1 = 15000.0;
int R2 = 15000.0; //Wert des bekannten Widerstands
int R3 = 15000.0;
int R4 = 15000.0; //Wert des bekannten Widerstands
long Messwert1;
long Messwert2;
float SpannungU1;
float SpannungU2; //Spannung über dem zu messenden Widerstand
float SpannungU3;
float SpannungU4; //Spannung über dem zu messenden Widerstand
float SpannungLB;
float Widerstand;
float Widerstand2;

//Variablen Taster
int tasterRechts = 0;
int tasterLinks = 0;
int endschalterLinks = 0;
int endschalterRechts = 0;
int tasterVersuch = 0;

// Entprellen Taster
int reading;               // Wert des Eingangs
int previous = LOW;    // Vorheiger Wert des Eingangs
unsigned long time = 0;         // letzter Zeitwert bei dem der Ausgangzustand wechselte.
unsigned long debounce = 500;   // Entprellzeit

//Variablen Led
int b = 0;
int i = 0;
boolean value=LOW;   // Startwert der LED
unsigned long previousMillis = 0;  //speichert wieviele Sekunden seit der letzten Veränderung vergangen ist
unsigned long interval = 100;   //Intervallänge

//---------------------------------------------------------------------------------------------

// stepper motor Functionen
void forwardstep() {  
  digitalWrite(dirPin, HIGH);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(1);
  digitalWrite(stepPin, HIGH);
}

void backwardstep() {  
  digitalWrite(dirPin, LOW);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(1);
  digitalWrite(stepPin, HIGH);
}

// setting up the AccelStepper library with custom actuator functions
AccelStepper stepper(forwardstep, backwardstep); // use functions to step


void drehunglinks(){
     backwardstep();
     Serial.println("Drehung Links rueckwaerts");
}

void drehungrechts(){
     forwardstep();
     Serial.println("Drehung Rechts vorwaerts");
}

void motorRueckrechts(){
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();
     drehunglinks();                    
     Serial.println("Endschalter rechts");
     b = 1;
    }

void motorRuecklinks(){
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     drehungrechts();
     Serial.println("Endschalter links");
     b = 1;
    }


// Bewegungsprofil Lukas 
void bewegungsprofilA(){

     stepper.setCurrentPosition(0);
     stepper.runToNewPosition(-20);
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-20);
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-20);     
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-20);     
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-20);     
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-20);         
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-20);
     stepper.runToNewPosition(20);
     stepper.runToNewPosition(-240);
  }


// Auseinanderfahren bis Lichtbogenabriss, danach noch 5 Steps weiter
void bewegungsprofilB(){
  
    while (SpannungLB < Quellspannung)
      {
       digitalWrite(led1Pin, HIGH);
       drehunglinks();
       spannungsteiler(); 
      }
       digitalWrite(led1Pin, LOW); 
       drehunglinks();
       drehunglinks();
       drehunglinks();
       drehunglinks();       
       drehunglinks();    
    } 


// Auseinanderfahren auf 4mm 
void bewegungsprofilC(){

     stepper.setCurrentPosition(0);
     stepper.runToNewPosition(-400);  
   }


// Spannungsberechnung des Lichtbogens über Spannungsteiler 
void spannungsteiler(){
      //5 Messungen machen und Mittelwert bilden
      Messwert1=0;
      for(int i=0;i<5;i++){
        Messwert1+=analogRead(AnalogPin1);
      }
      Messwert1 = trunc((Messwert1)*1/5);
    
      //5 Messungen machen und Mittelwert bilden
      Messwert2=0;
      for(int i=0;i<5;i++){
        Messwert2+=analogRead(AnalogPin2);
      }
      Messwert2 = trunc((Messwert2)*1/5);
        
        //Spannungen berechnen
        SpannungU2=(Quellspannung/1023.0)*Messwert1;
        SpannungU1=(Quellspannung-SpannungU2);
        SpannungU4 = (Quellspannung/1023.0)*Messwert2;
        SpannungU3 = (SpannungU1*(SpannungU4/SpannungU2));
        SpannungLB = Quellspannung - SpannungU3 - SpannungU4;
        
//        Serial.print("Spannung ueber R1 betraegt ");
//        Serial.print(SpannungU1,2);
//        Serial.println(" Volt!");
//      
//        Serial.print("Spannung ueber R2 betraegt ");
//        Serial.print(SpannungU2,2);
//        Serial.println(" Volt!");
//      
//        Serial.print("Spannung ueber R3 betraegt ");
//        Serial.print(SpannungU3,2);
//        Serial.println(" Volt!");
//      
//        Serial.print("Spannung ueber R4 betraegt ");
//        Serial.print(SpannungU4,2);
//        Serial.println(" Volt!");

        Serial.print("Spannung ueber Lichtbogen betraegt ");
        Serial.print(SpannungLB,2);
        Serial.println(" Volt!");
        Serial.println();
        Serial.println("-----------------------------------------");
        Serial.println();
        
//        delay(1000);
}


// Led Blinken
void blinken(){
      if (i<8){
      if(millis()-previousMillis > interval)
      {
      previousMillis = millis();// aktueller Zeitspeicher
      value = !value; // Zustand der LED ändern
      digitalWrite(led1Pin,value);
      i++;
      }
      }
    }


//---------------------------------------------------------------------------------------------

void setup()
{
   Serial.begin(9600);  // configuration of gpio interface
   
   pinMode(stepPin, OUTPUT);
   pinMode(dirPin, OUTPUT); 
   pinMode(disablePin, OUTPUT); 
   pinMode(led1Pin, OUTPUT);
   pinMode(led2Pin, OUTPUT);
   pinMode(buttonPin1, INPUT);
   pinMode(buttonPin2, INPUT);
   pinMode(buttonPin3, INPUT);
  
   digitalWrite(disablePin, HIGH);
  
   // ramp parameters
   stepper.setMaxSpeed(200);
   stepper.setAcceleration(300);

   // Interups
   attachInterrupt(0, motorRuecklinks, RISING);     //Pin D2 Endschalter Links
   attachInterrupt(1, motorRueckrechts, RISING);    //Pin D3 Endschalter Rechts

   
}

//---------------------------------------------------------------------------------------------


void loop()
{   
    tasterRechts = digitalRead(buttonPin1);     
    tasterLinks = digitalRead(buttonPin2);
    tasterVersuch = digitalRead(buttonPin3);

  


         // Beim Wechsel des Eingangs von LOW zu HIGH und nach der Entprellzeit:
     if (tasterRechts == HIGH && previous == LOW && millis() - time > debounce) {
         time = millis();  
         drehungrechts();
//         digitalWrite(led2Pin, HIGH);
         previous = reading;
         while (previous == HIGH)
               {
                 drehungrechts();
               }
//         digitalWrite(led2Pin, LOW);
       }
  

      else if (tasterLinks == HIGH && previous == LOW && millis() - time > debounce) {
               time = millis();  
               drehunglinks();
               previous = reading;
               while (previous == HIGH)
                     {
                       drehunglinks();
                     }
 //              digitalWrite(led2Pin, LOW);
      }
              
      else {   if (tasterVersuch == HIGH && previous == LOW && millis() - time > debounce) {
                   time = millis();
                   spannungsteiler();   
                   bewegungsprofilB();
                   previous = reading;
                 }
           }

    if (b == 1){
      blinken();
 //         b = 0; 
    }

     
   }



//---------------------------------------------------------------------------------------------

Eric B. schrieb:
> Michael L. schrieb:
>> Warum ist das so?
>
> Weil dein Code, den wir nicht kennen, einen Bug hat.

So da isser.

[Einer K. (Gast)]

Ich fange mal an...
Aber da ist so viel drin, dass mir fast schwindelig wird.

Du hast da 2 Endlosschleifen drin...
Und, wenn sie nicht endlos sind, dann sind sie sowieso überflüssig.
HIGH  und  LOW sind nicht int, sondern bool. (auch wenn es hier wenig 
Unterschied macht.)

b ist nicht volatile, das ist ein grober Fehler.
Serial.print() und seine Brüder können deine ISR in den Deadlock 
zwingen.

Auf jeden Fall würde ich das "entkoppeln".
Damit meine ich z.B. das Debounce als einzelnen Teil auslagern.
3 Bedingungen in einer IF gelten bei mir schon als 
unlesbar/unübersichtlich.

[Falk B. (falk)]

@  Michael L. (strompaedagoge)

>>> Michael L. schrieb:
>>> Warum ist das so?
>>
>> Weil dein Code, den wir nicht kennen, einen Bug hat.

>So da isser.

Der gehört in den ANHANG!!

[Eric B. (beric)]

Michael L. schrieb:
> void motorRueckrechts(){
>      drehunglinks();
>      ...
>     }
>
> void motorRuecklinks(){
>      drehungrechts();
>      ...
>     }
>...
> void setup()
> {
...
>    // Interups
>    attachInterrupt(0, motorRuecklinks, RISING);     //Pin D2 Endschalter
> Links
>    attachInterrupt(1, motorRueckrechts, RISING);    //Pin D3 Endschalter
> Rechts
> }

Also, wenn der Motor ganz links angekommen ist, löst er einen Interrupt 
auf Pin D2 aus, dreht wie verrückt nach rechts, bis zum Anschlag rechts. 
Dann löst er da einen Interrupt auf Pin D3 aus, und dreht wie verrückt 
nach links, bis zum Anschlag. Dann löst er einen Interrupt auf Pin D2 
aus, dreht wie verrückt nach rechts, usw.
Oder braucht der mehr als 10 Drehungen um bis zum Anschlag zu kommen?

EDIT:
Irgendwas N-fach wiederholen macht man so:

for(uint8_t i = 0; i < N; i++)
{
    irgendwas();
}

z.B.

void motorRuecklinks()
{
    for(uint8_t i = 0; i < 10; i++)
    {
        drehungrechts();
    }
    Serial.println("Endschalter links");
    b = 1;
}

[Arduinoquäler (Gast)]

Michael L. schrieb:
> // Example of driving a stepper motor using

Wichtige Regeln - erst lesen, dann posten!

    Groß- und Kleinschreibung verwenden
    Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

-------------------------------------------

Hallo Michael L.,

Ergänzung: erst lesen, dann verstehen, dann posten!

[Michael L. (strompaedagoge)]

Arduino F. schrieb:
> Ich fange mal an...
> Aber da ist so viel drin, dass mir fast schwindelig wird.
>
> Du hast da 2 Endlosschleifen drin...
> Und, wenn sie nicht endlos sind, dann sind sie sowieso überflüssig.
> HIGH  und  LOW sind nicht int, sondern bool. (auch wenn es hier wenig
> Unterschied macht.)
>
> b ist nicht volatile, das ist ein grober Fehler.
> Serial.print() und seine Brüder können deine ISR in den Deadlock
> zwingen.
>
> Auf jeden Fall würde ich das "entkoppeln".
> Damit meine ich z.B. das Debounce als einzelnen Teil auslagern.
> 3 Bedingungen in einer IF gelten bei mir schon als
> unlesbar/unübersichtlich.

Okay den voherigen Beitrag kann ich nicht mehr bearbeiten um den Code in 
den Anhang zu packen.

Wo siehst du zwei Endlosschleifen?

Das debouncen ist etwas unschön, geb ich zu. Funktioniert aber zum 
Glück.

Serial.print() war halt eine einfache Möglichkeit zum Überprüfen. Ist 
für die spätere Verwendung nicht erforderlich. Fliegt also erstmal raus.

Der Motor braucht deutlich mehr Schritte um von einem Endschalter zum 
anderen zu kommen (>1000).

Fällt ja gar nicht auf das ich vom programmieren eher wenig Ahnung habe. 
;)

[Einer K. (Gast)]

Hier:

 while (previous == HIGH)
                     {
                       //
                     }

Ich sehe nicht, wo in der Schleife, previous sich je ändern könnte.

Also gibts nur zwei Möglichkeiten:
1. die Schleife wird nicht durchlaufen (dann kann sie weg)
2. die Schleife wird endlos durchlaufen (Programm "hängt")

[Michael L. (strompaedagoge)]

Arduino F. schrieb:
> Hier:
>

>  while (previous == HIGH)
>                      {
>                        //
>                      }
>

> Ich sehe nicht, wo in der Schleife, previous sich je ändern könnte.
>
> Also gibts nur zwei Möglichkeiten:
> 1. die Schleife wird nicht durchlaufen (dann kann sie weg)
> 2. die Schleife wird endlos durchlaufen (Programm "hängt")

Scheinbar braucht der das previous gar nicht.

Eigentlich soll der bei einem Tastendruck einen Schritt vorwärts machen 
und wenn der Taster gedrpückt bleibt sich einfach weiter drehen.....

[Bitwurschtler (Gast)]

Michael L. schrieb:
> Hat jemand eine Idee womit ich eine einfache kurze Pause zwischen dem
> wechseln des Status der LED realisieren kann

Externe Schaltung zum Blinken im ISR Triggern.

[Nosnibor (Gast)]

Daß das Blinken nur einmal funktioniert liegt daran, daß die beteiligten 
Variablen (b und i) hinterher nicht wieder in den Ausgangszustand 
gesetzt werden.
blinken() braucht noch einen else-Zweig, damit, wenn i>=8 ist (also wenn 
das Blinksignal fertig ist), der Ausganszustand wiederhergestellt wird, 
also b=0 und i=0.

[Eric B. (beric)]

Siehe Anhang. Keine Garantie dass es funktioniert, oder überhaupt 
annähernd macht was du denkst das es tun soll, aber es kompiliert ;-)

Ah, .cpp in .ino oder so was umbenennen für Arduino.