generelle Frage zur Programmstruktur

[Michael (Gast)]

Hi,

ich hab ein kleines Problem damit, meine µC-Applikation zu schreiben. 
Also, es scheitert nicht an der Programmierung an sich, sondern an der 
Art der Lösung. Ich habe die Einzelteile, also z.B. Treiber für Display, 
Tastatur usw. schon geschrieben, sie funktionieren auch, soweit ich das 
Austesten konnte.

Das Problem besteht nun darin, dass ich es nicht schaffe, die Teile so 
zusammen zu pfriemeln, dass sich eine gescheite Applikation ergibt. 
Konkret scheitert es eigentlich schon am Ansatz :(

Vom Gefühl her würde ich sagen, dass es am besten ist, wenn ich das 
Programm so schreibe, dass an keiner Stelle auf irgendwas gewartet, 
sondern nur geprüft wird, ob etwas an der entsprechenden Stelle gemacht 
werden muss -> State-Machine?

Diesen Ansatz (ohne State-Machine) habe ich nun versucht zu 
implementieren, d.h. in der Main-Schleife laufen zwei Sachen. Erstens 
eine Auswertung von empfangenen DCF77-Daten (die Daten selbst lese ich 
in einem Interrupt aus -> funktioniert). Das zweite ist eine 
Menü-Ausgabe.

Die Menü-Ausgabe ist etwas spezieller, weil dort momentan irgendwie 
alles abläuft, deswegen erklär ich das mal genauer:

Die Menü-Funktion prüft, ob eine der vier Navigationstasten gedrückt 
wurde. In Abhängigkeit davon wird ein Pointer auf ein Menü-Element 
gesetzt.
Das Menü-Element hat folgenden Aufbau:

typedef struct m_item{
  struct m_item *Up;
  struct m_item *Down;
  struct m_item *Left;
  struct m_item *Right;
  void (code *fpPtr)(void);
} _stMenu;

Die ersten vier Einträge zeigen jeweils auf den 
oberen/unteren/linken/rechten Knoten des Menüs, bzw. auf NULL(nicht 0), 
wenn's keinen direkten Nachbarn mehr gibt. Die Menü-Struktur wird über 
ein entsprechendes Array der Menü-Elemente realisiert.
Der fünfte Eintrag ist ein Funktionspointer. Die entsprechende Funktion 
wird bei jedem Aufruf der Menü-Funktion aufgerufen, unabhängig davon, ob 
eine der Richtungstasten gedrückt wird.
Zusätzlich kann die Abfrage der Navigations-Tasten in der Menü-Funktion 
durch ein globales Flag gesperrt werden, um die Navigationstasten für 
die aufgerufenen Funktion freizumachen.
Die aufgerufenen Funktionen übernehmen alles, von der Display-Anzeige 
über die Tastatur-Eingaben, bis hin zu IO-Aufgaben.
So, und ich glaube mit dem Ansatz hab ich mir n Ei gelegt. Erstens 
gibt's irgendwie Kuddelmuddel, zweitens gefällt es mir vom Gefühl her 
nicht, und dritten tut's eh nicht :(

Die Frage wär jetzt, wie realisiert man sowas richtig? Und zwar nicht 
auf ein spezielles Problem bezogen, sondern allgemein.

Hierzu mal meine Überlegungen. Ich denke, ich brauch definitiv ne 
State-Machine. Punkt.
Wie bau ich die denn nun auf? Eine Variable für alle Zustände, oder für 
jeden Part (Tastatur, LCD, usw.) eine eigene Variable?
Wenn ich nur eine Variable verwende, gibts ja irgendwie wieder ein 
Durcheinander, weil dann m.E. die Eingabe nicht sauber von der Ausgabe 
getrennt ist.
Also eher der Ansatz von voneinander unabhängigen State-Variablen. Und 
wie realisiert man dann sowas? Wie sieht das Grundgerüst aus? Hat mir 
vielleicht jemand Pseudocode?
Oder ist der Ansatz auch murks?

Ich hoffe, ich konnte alle relevanten Infos liefern :)

Vielen Dank schonmal

Michael

[Εrnst B. (ernst)]

Menus implementier ich meist ähnlich, und hab dort fast alles innerhalb 
meiner menu-structs definiert:

#define CODE_LEFT   0
#define CODE_RIGHT  1
#define CODE_PRESS  2
#define CODE_IDLE   3
#define FAST_IDLE   4
#define CODE_ENTER  5
#define CODE_LEAVE  6
#define CODE_UPDATE 7

#define EVENT_ENTER  1
#define EVENT_LEAVE  2
#define EVENT_UPDATE 3

#define SHORT_IDLE_SECONDS 5
#define LONG_IDLE_SECONDS 30

typedef void (*display_func)(uint8_t);

struct menu_entry {
  const prog_char * text;
  display_func display;
  const void * left;
  const void * right;
  const void * press;
  const void * idle;

  uint8_t flags;
};

Je nach gesetztem "CODE_XXX" Flag sind die Void-Pointer Verweise auf den 
nächsten eintrag, oder Funktionspointer, die aufgerufen werden.
die display_func wird jde nach CODE_ENTER,CODE_LEAVE,CODE_UPDATE 
aufgerufen (Mit EVENT_XXX) als Parameter, und kann z.B. im "Enter" einen 
Wert aus dem EEPROM auslesen, im update darstellen, und beim Leave 
wieder ins eeprom zurückspeichern. Die left/right-Funktionen dienen dann 
zum einstellen des Wertes.

Beispiel um eine Uhrzeit einzustellen:

extern struct menu_entry PROGMEM menu_time;
extern struct menu_entry PROGMEM menu_time_hour;
extern struct menu_entry PROGMEM menu_time_minute;
extern struct menu_entry PROGMEM menu_time_second;
extern struct menu_entry PROGMEM menu_time_weekday;

static const prog_char text_time[]         = "Uhr stellen     ";
static const prog_char text_empty[]        = "                ";

static void display_time_minute(uint8_t flags);
static void rotate_time_minute(int8_t amount);
static void display_time_second(uint8_t flags);
static void rotate_time_second(int8_t amount);
static void display_time_weekday(uint8_t flags);
static void rotate_time_weekday(int8_t amount);
[...]

struct menu_entry PROGMEM menu_time={
  text_time,
  NULL,
  &menu_switchpoints,
  &menu_clocktune,
  &menu_time_hour,
  &menu_idle,      // Idle
  0
};
struct menu_entry PROGMEM menu_time_hour={
  text_empty,
  display_time_hour,
  rotate_time_hour,
  rotate_time_hour,
  &menu_time_minute,
  &menu_idle,      // Idle
  _BV(CODE_ENTER)|_BV(CODE_LEAVE)|_BV(CODE_UPDATE)|_BV(CODE_LEFT)|_BV(CODE_RIGHT)
};
struct menu_entry PROGMEM menu_time_minute={
  text_empty,
  display_time_minute,
  rotate_time_minute,
  rotate_time_minute,
  &menu_time_second,
  &menu_idle,      // Idle
  _BV(CODE_ENTER)|_BV(CODE_LEAVE)|_BV(CODE_UPDATE)|_BV(CODE_LEFT)|_BV(CODE_RIGHT)
};
[usw]
void display_time_hour(uint8_t flags) {
  display_time_edit(flags);
  if (flags == EVENT_UPDATE) {
    // Move Cursor
    lcd_command(LCD_CMD_DDRAM|0);
  }
}

void display_time_minute(uint8_t flags) {
  display_time_edit(flags);
  if (flags == EVENT_UPDATE) {
    // Move Cursor
    lcd_command(LCD_CMD_DDRAM|3);
  }
}
void rotate_time_minute(int8_t amount) {
idle_counter=0;
 cli();
 uint16_t minutes=clock.minutes;
 uint8_t mins=minutes%60;
 if (amount < 0) {
   if (mins!=0) {
     minutes-=1;
   } else {
     minutes+=59;
   }
 }
 if (amount > 0) {
   if (mins!=59) {
     minutes+=1;
   } else {
     minutes-=59;
   }
 }
 clock.minutes=minutes;
 sei();
}

Angetrieben wird die State-Maschine dann in der Main-Schleife über 
Keypresses und timer-flags:

     key=kbd_get_keys(_BV(KEY_PRESS));
     delta=kbd_get_delta();
     nextaction.v=0;
     is_code=0;
     if (key & _BV(KEY_PRESS)) {
        nextaction.v=&current_menu->press;
        is_code=current_menu_flags & _BV(CODE_PRESS);
     }
     if (delta < 0) {
        nextaction.v=&current_menu->left;
        is_code=current_menu_flags & _BV(CODE_LEFT);
     }
     if (delta > 0) {
        nextaction.v=&current_menu->right;
        is_code=current_menu_flags & _BV(CODE_RIGHT);
    }
    if (idle_counter > (uint8_t)(((current_menu_flags & _BV(FAST_IDLE))?SHORT_IDLE_SECONDS:LONG_IDLE_SECONDS) / TIMER0_IVAL / 256)) {
        idle_counter=0;
        nextaction.v=&current_menu->idle;
        is_code=current_menu_flags & _BV(CODE_IDLE);
    }
    if (nextaction.v) {
       nextaction.v=(void *)pgm_read_word(nextaction.v);
    }
    if (nextaction.v) {
       if (is_code) {
         nextaction.c(delta);
       } else {
         switch_menu(nextaction.m);
       }
    }
    if (scroll_flag) {
      scroll_display();
    }

Hoffe die Code-Fragmente helfen dir weiter, wenn vielleicht auch nur als 
abschreckendes Beispiel...

[tuppes (Gast)]

> Die aufgerufenen Funktionen übernehmen alles,
> von der Display-Anzeige über die Tastatur-Eingaben,
> bis hin zu IO-Aufgaben.

Konsequenz daraus ist: Solange eine der Menüfunktionen läuft, ist alles 
andere tot. Ist das vielleicht das Problem?

[Michael (Gast)]

Hallo,

sorry für die späte Antwort.

@Ernst:

Danke, ich werd mir deinen Code mal durchlesen.

@Tuppes:

> Konsequenz daraus ist: Solange eine der Menüfunktionen läuft, ist alles
> andere tot. Ist das vielleicht das Problem?
Nein, es ist eben nicht alles andere tot, die Funktionen sind extra so 
geschrieben, dass nix stehenbleibt. Aber irgendwie wird alles dort 
gemacht, und das fühlt sich eben nicht richtig an. Ich bin der Meinung, 
dass sich das sauberer trennen lassen muss, nur fehlt mir dazu der 
Lösungsansatz.

Michael