Switch-Case Anweisung für Events

[Switcher (Gast)]

Hallo,

ich habe ein Programm, welches im wesentlichen aus einer Sleep-Zeit 
besteht und mehreren Anweisungen, die sporadisch auftreten können.

Die Hauptfunktion sieht also wie folgt aus:

if(Taskregister==FLAG_IDLE)
{
LPM3;
}

else 
{
Taskmanager();
}

und der eigentliche Taskmanager wie folgt:

int32_t Taskmanager()
{
switch(Taskregister)
{
case FLAG_MEASURE:  // in Timer ISR gesetzt
  Measure(&Messergebnisse);    
  set(&Taskregister, FLAG_EVALUATE);
  reset(&Taskregister, FLAG_MEASURE); 
  set  (&Taskregister, FLAG_TEMP_START);
  //no break Fallthrough

case FLAG_EVALUATE:
  reset(&Taskregister, FLAG_EVALUATE);
  my_itoa_4digit(Messergebnisse.Wert, string_array);
  add_string_to_uart_tx_buffer(&TX_Ringbuffer, Wert);
  
case FLAG_TEMP_START:
  uart_transmit();
  Measure_Temp();
  reset(&Taskregister, FLAG_TEMP_START);
  break;
...
weitere cases

Hinter dem Flag-Register verbirgt sich:

#define FLAG_IDLE   0x0000
#define FLAG_MEASURE   0x0001
#define FLAG_EVALUATE  0x0002
#define FLAG_UART  0x0004

... weitere Flags...


volatile extern uint32_t Taskregister;

Nun ist die Idee dahinter natürlich, dass die einzelnen Flags an 
unterschiedlichen Positionen und auch durch unterschiedliche externe 
Ereignisse gesetzt werden können.
Das funktioniert auch soweit, solange nur ein einziges Flag zur Zeit 
gesetzt ist.
Sobald aber aus welchen Gründen auch immer mehrere Flags gesetzt sind, 
z.B. zeitgleich das 0. und 1. Bit meines Flagregisters, so ist das 
Resultat dann ja dezimal "3" und die Switch-Case Anweisung findet diesen 
Fall nicht mehr... bzw. fängt an einem falschen Punkt an, in die 
Switch-case Anweisung hineinzulaufen

Wie kann ich dieses Problem umgehen und dabei die oben skizzierte 
Strategie der Eventbehandlung beibehalten?

[Pandur S. (jetztnicht)]

Indem man nur das betreffende flag zuruecksetzt und nicht alle.

[Klaus W. (mfgkw)]

if( Taskregister | FLAG_MEASURE )
{
    // ...
}
if( Taskregister | FLAG_EVALUATE )
{
    // ...
}
if ...

[Matthias L. (Gast)]

Da offensichtlich mehrere Events auftreten können, wäre vielleicht ein 
kleines FIFO interessant? Dort kann der "Taskmanager" abzuarbeitende 
Events entnehmen, während woanders welche produziert werden...

[W.S. (Gast)]

Switcher schrieb:
> ich habe ein Programm, welches im wesentlichen aus einer Sleep-Zeit
> besteht und mehreren Anweisungen, die sporadisch auftreten können.

Switcher schrieb:
> Wie kann ich dieses Problem umgehen und dabei die oben skizzierte
> Strategie der Eventbehandlung beibehalten?

Du arbeitest doch garnicht mit Events. Deine Art zu Programmieren, die 
du hier gezeigt hast, ist überhaupt nicht ereignisgesteuert, sondern 
schlichtweg prozedural.

Deine case Kaskade ist - wenn man sie mal auf's Wesentliche 
zusammenstaucht doch so:

immerzu:
  Measure();
  ConvToString();
  GibStringAus();
  MeasureTemp();
  GibTempAus();
  goto immerzu;

Das hat mit ereignisgesteuerten Abläufen keinelei Ähnlichkeit. Du kannst 
also sinnvollerweise nur eines tun: alles in die Tonne und ganz neu 
beginnen.

W.S.

[Joe F. (easylife)]

"set" und "reset" sollte man als funktionsnahen besser vermeiden.
ansonsten:

if (Taskregister & FLAG_MEASURE)
{
  reset_flag(&Taskregister, FLAG_MEASURE); 
  set_flag  (&Taskregister, FLAG_EVALUATE);
  set_flag  (&Taskregister, FLAG_TEMP_START);
  Measure(&Messergebnisse);    
}

if (Taskregister & FLAG_EVALUATE)
{
  reset_flag(&Taskregister, FLAG_EVALUATE);
  my_itoa_4digit(Messergebnisse.Wert, string_array);
  add_string_to_uart_tx_buffer(&TX_Ringbuffer, Wert);
}
  
if (Taskregister & FLAG_TEMP_START)
{
  reset_flag(&Taskregister, FLAG_MEASURE); 
  uart_transmit();
  Measure_Temp();
}

[Switcher (Gast)]

selbstverständlich arbeite ich mit Events.

Events treten z.B. dann auf, wenn der UART-Buffer mal wieder ein neues 
Byte haben möchte, um einen Text innerhalb der Sleepphase zu übertragen.

Und Events treten auch dann auf, wenn externe Sensoren erst nach einer 
definierten Zeit einen Messwert bereit stellen,

Und events treten auch dann auf, wenn mal ein externer Taster gedrückt 
wird...

Nur weil einige dieser Zeiten theoretisch bis auf einige Millisekunden 
genau vorhersehbar sind, heisst das doch nicht, dass dies kein event 
darstellt.


Ist ja auch egal, wahrscheinlich ist es mit den IF-Abfragen am 
einfachsten um zu stricken...

[Joe F. (easylife)]

soll natürlich heissen:

if (Taskregister & FLAG_TEMP_START)
{
  reset_flag(&Taskregister, FLAG_TEMP_START); 
  uart_transmit();
  Measure_Temp();
}