Interrupts während einer schleife

[Sascha712 (Gast)]

Hallo,

Ich habe 3 Fall unterscheidungen.
Wenn der UC angeht, ist er in Fall 1. per INT1 und INT0 erzeuge ich 
interrupts, die den fall ändern, entweder zu fall  oder fall 3.

Nun soll sobald ein Interrupt passiert ist der Fall sich sofort ändern. 
Wenn ich aber zb. eine längere schleife habe, springt er ja nach dem 
Interrupt an die letzte "arbeitsposition" und macht dort weiter, obwohl 
der fall gar nicht mehr aktuell ist.

while(1)
  {
          
          switch(fall)
          {
            case 1: PORTB |= (1<<PINB2);      //PB2
                PORTB &= ~(1<<PINB1);
                PORTB &= ~(1<<PINB7);
                _delay_ms(6000);
                break;
            case 2: PORTB |= (1<<PINB1);      //PB1
                PORTB &= ~(1<<PINB2);
                PORTB &= ~(1<<PINB7);
                _delay_ms(6000);            
                break;
            case 3: PORTB |= (1<<PINB7);      //PB7
                PORTB &= ~(1<<PINB1);
                PORTB &= ~(1<<PINB2);
                _delay_ms(6000); 
                break;
          }



  }

ISR(INT0_vect)
{
  fall=2;
}


ISR(INT1_vect)
{
  fall=3;
}

Wie kann ich das lösen, dass er direkt den alten Fall beendet und schaut 
welcher der neue Fall ist?

gruß

[Uwe Bonnes (Gast)]

Dein _delay_ms(6000) wir immer fertig ausgefuehrt. Da musst Du 
eingreifen, z.b etwa wie
          switch(fall)
          {
            case 1: PORTB |= (1<<PINB2);      //PB2
                PORTB &= ~(1<<PINB1);
                PORTB &= ~(1<<PINB7);
                delay = 6000;
                while ((fall == 1) && delay) {
                     _delay_ms(1);
                     delay --;
                }
                break;

[Karl H. (kbuchegg)]

Sascha712 schrieb:

> Nun soll sobald ein Interrupt passiert ist der Fall sich sofort ändern.
> Wenn ich aber zb. eine längere schleife habe,

schon falsch.
Dann darfst du eben keine längere Schleife haben.

konkret in deinem Programm: welchen Sinn haben denn die _delay_ms? 
Richtig. Gar keinen.

_delay_ms (insbesondere längere) sind selten die Lösung, aber oft das 
Problem.

[Sascha712 (Gast)]

Könnte ich das (fall == 1) nicht auch weglassen? wird doch schon durch 
case 1: bestimmt?

          switch(fall)
          {
            case 1: PORTB |= (1<<PINB2);      //PB2
                PORTB &= ~(1<<PINB1);
                PORTB &= ~(1<<PINB7);
                delay = 6000;
                while (delay) {
                     _delay_ms(1);
                     delay --;
                }
                break;

[Sascha712 (Gast)]

Die delays sind da grad nur, damit ich das auf meinem steckbrett sehen 
kann, das der interrupt eingreift. Später wird das anders sein und ich 
werd auch höchstens delays von 17ms haben.

[Karl H. (kbuchegg)]

Sascha712 schrieb:
> Könnte ich das (fall == 1) nicht auch weglassen?


In Uwes Version nicht

> wird doch schon durch
> case 1: bestimmt?

Du willst doch, dass die ganze Delay Sache sofort unterbrochen wird, 
sobald durch einen Interrupt ein anderer Fall eingestellt wird. Also ist 
eben nicht gewährleistet, dass fall ständig die ganze Zeit den Wert 1 
hat.

Das hier

   delay = 6000;
   while (delay) {
     _delay_ms(1);
   delay --;

bringt dir nichts. Da hättest du genausogut auch gleich

    _delay_ms( 6000 );

schreiben können.
Der ganze Witz in Uwes Lösung besteht ja darin, dass es hier

   delay = 6000;
   while ((fall == 1) && delay) {
     _delay_ms(1);
     delay --;
   }

2 Bedingungen gibt, unter denen die Wartezeit abgebrochen wird.
Einmal wenn die Wartezeit abgelaufen ist
und die zweite mögliche Bedingung besteht darin, dass ein Interrupt 
einen anderen fall eingestellt hat. Auch denn wird die Schleife 
spätestens 1ms später abgebrochen, weil dann fall eben nicht mehr 1 ist.

Aber tatsächlich ist die Lösung eher schlecht, denn du musst jeden delay 
einzeln pimpen. Das erledigt man anders, in dem man die Hauptschleife 
auf eine konstante Länge von zb 1ms bringt und dann einen Zähler 
installiert, der zb von einer eingestellten Wartezeit runterzählt.

[Sascha712 (Gast)]

Dazu müsste ich aber auch wissen wieviele Takte er pro schelife den 
abarbeitet ^^ Hab aber kein debug tool um das iwie zu messen oder so.
Danke für die Erklärung :)

[Flohzirkus (Gast)]

Wie wär's mit:

uint8_t oldFall = ...;

....

while (1){
  uint8_t newFall = fall; //nur ein Zugriff auf fall, falls der Interrupt dies gerade ändert
  if (newfall != oldfall){
    oldfall = newfall;
    switch (newfall){
       //ohne delay !
    }
  }
}