Mejores prácticas para mantener main() en los sistemas embebidos

Question

Me gustaría saber una cosa sobre cómo mantener el main() en la práctica de la codificación embebida. Tengo un sistema autónomo que tiene n número de estados y se trasladaría a los respectivos estados.

Al principio hice un while(1) condición en main() y se comprueba si se produce alguno de los estados:

main()
{
  initialize;

  while(1)
  {
    check for state n.

    if state n found

    GoTo state n
  }
}

No sé si me he equivocado al definir el estado n dentro del propio main. ¿O debo separar el estado n definición separándola de main() y llamando al estado n función de main() ?

Quiero practicar el mejor estándar de codificación. ¿Cuál es el método mejor practicado en los sistemas embebidos para mantener la main() ?

Me gustaría tener aportes de su parte para tener la mejor estructura para definir los métodos de codificación incrustados para mantener main() y los archivos fuente correspondientes.

¿Qué ocurrirá cuando los estados se vuelvan elaborados y complejos? ¿Cómo debería mantener el main() ? Confío en que la codificación se mantenga ordenada. Agradecería sus valiosas aportaciones y sugerencias.

Answer 1

Si te preocupa que el código de un simple switch() Si la máquina de estado (SM) se vuelve desordenada, puede dividirla en subrutinas más pequeñas.

void do_state_s1() {
    // stuff
    if ( /* certain  contidition */ ) {
        g_iState = STATE_S2;  // transition to another state
    }
}

void do_state_s2()  {
    // other stuff
    if ( /* some other condition */ ) {
        g_iState = STATE_S1;
    }
}

void do_state_machine() {
    switch (g_iState) {
    case STATE_S1:
        do_state_s1();
        break;

    case STATE_S2:
        do_state_s2();
        break;
    };
}

void main() {
    g_iState = STATE_S1;        // initialize the SM

    while (1) {
        do_state_machine();
    }
}

Answer 2

Basado en la respuesta de @Nick Alexeev, estoy publicando una versión que utiliza una tabla de salto de puntero de función.

En mi opinión, esta es la forma ideal de implementar una máquina de estado para un sistema embebido, ya que deja la principal perfectamente limpia.

Y realmente no necesitas el switch En realidad, el compilador lo optimizará y lo convertirá en código máquina con una tabla de salto de punteros de función similar.

typedef enum
{
  STATE_S1,
  STATE_S2,
  ...
  STATE_N // the number of states in this state machine
} state_t;

typedef state_t (*state_func_t)(void);

state_t do_state_s1 (void);
state_t do_state_s2 (void);

static const state_func_t STATE_MACHINE [STATE_N] =
{
  &do_state_s1,
  &do_state_s2,
  ...
};

void main()
{
  state_t state = STATE_S1;

  while (1)
  {
    state = STATE_MACHINE[state]();
  }
}

state_t do_state_s1 (void)
{
  state_t result = STATE_S1;
  // stuff
  if (...) 
    result = STATE_S2;
  return result;
}

state_t do_state_s2 (void)
{
  state_t result = STATE_S2;
  // other stuff
  if (...) 
    result = STATE_S1;
  return result;
}