For Schleife mit user action unterbrechen

[King Julian (Gast)]

Ich habe eine for-Schleife mit integriertem Delay die für eine Ausgabe 
auf einem Display verantwortlich ist.

uint8_t k, j;
  for(k = 0; k < 23; k+=2){  
    for(j=0; j < 7; j++){
      DisplaySet(k, 1<<j);
      wait_ms(200);
    }
    for(j=0; j < 3; j++){
      DisplaySet(k+1, 1<<j);
      wait_ms(200);
    }
  }

Wenn ich nun die Möglichkeit haben möchte, diese Schleife mit einem User 
Input zu unterbrechen respektive in eine andere State der Statemachine 
wechseln möchte, wie löse ich das elegant?

Grundsätzlich komme ich ja wohl nicht darum herum meine Buttons anstatt 
zu pollen über Interrupts einzulesen?

[Falk B. (falk)]

@ King Julian (Gast)

>Wenn ich nun die Möglichkeit haben möchte, diese Schleife mit einem User
>Input zu unterbrechen respektive in eine andere State der Statemachine
>wechseln möchte, wie löse ich das elegant?

ohne wait_ms(200);

Siehe Multitasking

>Grundsätzlich komme ich ja wohl nicht darum herum meine Buttons anstatt
>zu pollen über Interrupts einzulesen?

Doch, Interrupts sind nicht zwingend nötig.

[Nop (Gast)]

King Julian schrieb:
> Wenn ich nun die Möglichkeit haben möchte, diese Schleife mit einem User
> Input zu unterbrechen respektive in eine andere State der Statemachine
> wechseln möchte, wie löse ich das elegant?

Mit einem "break"? (;

> Grundsätzlich komme ich ja wohl nicht darum herum meine Buttons anstatt
> zu pollen über Interrupts einzulesen?

Du wirst ja ohnehin einen Systemtimer haben. In dessen ISR kannst Du die 
Buttons pollen und das Debouncing machen. Wenn Du die Buttons direkt auf 
Interrupts legst, wird das Debouncing komplizierter.

Aus der ISR schiebst Du den einen Tastendruck in eine lockless queue. 
Die kannst Du dann abfragen, ob was drin ist, in den betreffenden 
Zustand springen und dort den Tastendruck aus der Queue holen.

[Programmierer (Gast)]

Kommt halt wie immer, auf die Gesammtumstände drauf an.

Eine Möglichkeit wäre etwa:

uint8_t wait_event_ms(volatile uint8_t *eptr, uint16_t timeout_ms)
{
  while (timeout_ms--) {
    wait_ms(1);
    uint8_t event = *eptr;
    if (event)
      return event;
  }
  return 0; // Kein Event aufgetreten
}

...

  volatile uint8_t event = 0;

  uint8_t k, j;
  for(k = 0; k < 23 && !event; k+=2){  
    for(j=0; j < 7 && !event; j++){
      DisplaySet(k, 1<<j);
      wait_event_ms(&event, 200);
    }
    for(j=0; j < 3 && !event; j++){
      DisplaySet(k+1, 1<<j);
      wait_event_ms(&event, 200);
    }
  }

So in der Art. Die Variable 'event' wird z.B. aus einem 
Interrupt-Handler beschrieben.

Alternativen und spielweisen gibt es davon unendlich viele. Z.b. könnte 
man aus wait_event_ms() auch einen entsprechenden Event-Handler direkt 
aufrufen, oder, oder, oder.

[Programmierer (Gast)]

Achso, besser wäre:

  volatile uint8_t event;

  ...

  uint8_t leave = event;
  uint8_t k, j;
  for(k = 0; k < 23 && !leave; k+=2){  
    for(j=0; j < 7 && !leave; j++){
      DisplaySet(k, 1<<j);
      leave = wait_event_ms(&event, 200);
    }
    for(j=0; j < 3 && !leave; j++){
      DisplaySet(k+1, 1<<j);
      leave = wait_event_ms(&event, 200);
    }
  }

[KingJulian (Gast)]

Also ich hab nun meinen Code umgestellt um etwas näher am Multitasking 
zu sein, und zwar hab ich meine Funktion, nennen wir sie mal foo(), mit 
einer Statemachine versehen. Das heisst ich habe die Funktion in 
einzelnen Unterfunktionen gegliedert von denen keine mehr die 
timeconstraints verletzen sollte.

Das Problem das ich nun habe ist, an der Stelle an der ich zuvor foo() 
einmal aufgerufen habe, muss ich foo() nun x-mal aufrufen (für alle 
Iterationen eben), aber wie teile ich dem darüber liegenden Code mit 
wenn aller Iterationen durchlaufen sind?

Ich hoffe das ist einigermassen Verständlich formuliert?

[Markus L. (rollerblade)]

> Das Problem das ich nun habe ist, an der Stelle an der ich zuvor foo()
> einmal aufgerufen habe, muss ich foo() nun x-mal aufrufen (für alle
> Iterationen eben)
Wie meinst Du das? Ich würde die Funktion timergesteuert alle 200ms 
aufrufen und in der Funktion die Statusvariablen k und j entsprechend 
modifizieren. Die beiden können dann natürlich nicht mehr lokal 
deklariert werden, da sie anfangs initialisiert und später immer wieder 
wiederverwendet werden sollen.
Eine Schleife (Iterationen) gibt es dann keine mehr, einen wait-Aufruf 
dann schon zweimal nicht mehr.

> aber wie teile ich dem darüber liegenden Code mit
> wenn aller Iterationen durchlaufen sind?
Versteh ich nicht. Ich würde die Funktion pauschal immer aufrufen, auch 
wenn sie dann feststellen sollte, daß es nix zu tun gibt. Wieso soll das 
der darüber liegende Code festellen? Der ruft ja wohl auch noch ganz 
andere Sachen auf. Der braucht die Funktionsweise der Funktion nicht zu 
kennen, denn dann müßte er sie potentiell alle kennen, die er aufruft. 
Das wäre dann Spaghetti-Code, unübersichtlich, fehleranfällig. Die 
Funktion kann ja ein beliebiger Handler für einen Timer-Event sein, und 
der darüber liegende Code - also der Aufrufer - wäre die Event-Loop, die 
nur den Typ Event-Handler kennt.

[stromtuner (Gast)]

>>bi sik biliyomus gibi yaziyonya anani sikesim geliyo gavat

Na, da hat sich einer aber eloquent artikluiert.
Herzlichen Glückwunsch!

StromTuner

[Manfred (Gast)]

King Julian schrieb:
> wait_ms(200);

Du hast offenbar Zeit, "wait_ms(200);". Sollte reichen, in eine andere 
Routine zu springen und die Tasten abzufragen (aka pollen). Dein wait 
muß dann natürlich auf einen absoluten Timer umgebaut werden.

[KingJulian (Gast)]

Markus L. schrieb:
>> Das Problem das ich nun habe ist, an der Stelle an der ich zuvor
> foo()
>> einmal aufgerufen habe, muss ich foo() nun x-mal aufrufen (für alle
>> Iterationen eben)
> Wie meinst Du das? Ich würde die Funktion timergesteuert alle 200ms
> aufrufen und in der Funktion die Statusvariablen k und j entsprechend
> modifizieren. Die beiden können dann natürlich nicht mehr lokal
> deklariert werden, da sie anfangs initialisiert und später immer wieder
> wiederverwendet werden sollen.
> Eine Schleife (Iterationen) gibt es dann keine mehr, einen wait-Aufruf
> dann schon zweimal nicht mehr.

Vielleicht ist das Problem nicht mehr ganz dasselbe wie im 
ursprünglichen Post. Also was ich machen will, ist im Prinzip eine LED 
faden ohne dabei andere zeitkritische Funktionen zu vernachlässigen. Das 
Faden ist aber auch nur ein Teil einer darüberliegenden Statemachine.

void MatrixEffectFade(void){
  typedef enum {  state_setFadeInOut, state_fade, state_complete } effectStates;
  static effectStates state = state_setFadeInOut;
  static uint8_t fadingIterations;
  int8_t fadeInOut[10][11];
  uint8_t i, j = 0;
  switch(state){
    case state_setFadeInOut:
      /* Set the matrix to define which LED to fade in respectively out */
      //Read actual matrix and save in currentFrame
      getCurrentMatrix();
      for(; i < 10;i++){
        for(; j < 11; j++){
          //If LED currently not set but set in new frame, set fadeInOut to 1
          if(currentFrame[i][j] == 0 && newFrame[i][j] != 0){
            //Fade in
            fadeInOut[i][j] = 1;
          //If LED currently set but not set in new frame, set fadeInOut to -1
          } else if(currentFrame[i][j] != 0 && newFrame[i][j] == 0){
            //Fade out
            fadeInOut[i][j] = -1;
          } else {fadeInOut[i][j] = 0;}
        }
      }
      fadingIterations = 0;
      state = state_fade;
      break;
      
    case state_fade:
      /* Fade the whole matrix one fading step */
      for(i=0; i < 10;i++){
        for(j=0; j < 11; j++){
          //If fading is over set all fading LEDs to target value 0 or maxBrightness
          if(fadingIterations == FADING_STEPS && fadeInOut[i][j] != 0){  //
            newFrame[i][j] = fadeInOut[i][j] == 1 ? getMaxBrightness() : 0;
          } else {
            newFrame[i][j] += fadeInOut[i][j]*(getMaxBrightness()/FADING_STEPS);
          }
        }
      }
      computeMatrix(newFrame);
      fadingIterations++;    
      break;
      
    case state_complete:
      state = state_setFadeInOut;
      break;
    default: break;
  }
}

>> aber wie teile ich dem darüber liegenden Code mit
>> wenn aller Iterationen durchlaufen sind?
> Versteh ich nicht. Ich würde die Funktion pauschal immer aufrufen, auch
> wenn sie dann feststellen sollte, daß es nix zu tun gibt. Wieso soll das
> der darüber liegende Code festellen? Der ruft ja wohl auch noch ganz
> andere Sachen auf. Der braucht die Funktionsweise der Funktion nicht zu
> kennen, denn dann müßte er sie potentiell alle kennen, die er aufruft.
> Das wäre dann Spaghetti-Code, unübersichtlich, fehleranfällig. Die
> Funktion kann ja ein beliebiger Handler für einen Timer-Event sein, und
> der darüber liegende Code - also der Aufrufer - wäre die Event-Loop, die
> nur den Typ Event-Handler kennt.

Damit meine ich, wenn die oben gelistete Statemachine im State 
state_complete angelangt ist, müsste die höherliegende Statemachine in 
einen anderen State wechseln, sonst beginnt das Faden ja wieder von 
vorne.

[Axel S. (a-za-z0-9)]

King Julian schrieb:
> Wenn ich nun die Möglichkeit haben möchte, diese Schleife mit einem User
> Input zu unterbrechen respektive in eine andere State der Statemachine
> wechseln möchte, wie löse ich das elegant?

Indem du keine solche Schleife schreibst.

So wie es aussieht, passiert nur alle 200ms etwas in dieser Schleife. 
Statt das nun in ein statische Gerüst zu zwängen, solltest du lieber 
eine Funktion schreiben, die die Schleifenvariablen als lokale Variablen 
hält und bei jedem Aufruf genau einen Interationsschritt macht. Diese 
Funktion mußt du dann nur einmal alle 200ms aufrufen. Z.B. aus einem 
Timerinterrupt. Oder - wenn das Timing paßt - aus deiner Hauptschleife.