Práctica recomendada para mantener main () en sistemas integrados

Navega tus respuestas
2

Me gustaría saber una cosa acerca de mantener el main() en la práctica de codificación integrada. Tengo un sistema independiente que tiene n número de estados y estaría cambiando a los estados respectivos.

Al principio hice una condición while(1) en main() y verifiqué que ocurriera alguno de los estados: 

main()
{
  initialize;

  while(1)
  {
    check for state n.

    if state n found

    GoTo state n
  }
}

No sé si cometí un error al definir el estado n dentro del main. ¿O debería separar la definición del estado n separándola de main() y llamando a la función del estado n de main() ?

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

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

¿Cuál será el caso cuando los estados se vuelvan elaborados y complejos? ¿Cómo debo mantener el main() ? Confío en que la codificación debe mantenerse ordenada. Apreciaría sus valiosos aportes y sugerencias.

    
pregunta Rookie91

2 respuestas

9

Si le preocupa que el código para una simple máquina de estado (SM) basada en switch() se vuelva desordenado, puede dividirlo 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();
    }
}
    
respondido por el Nick Alexeev
8

Según 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 estados para un sistema integrado, ya que deja a la red perfectamente limpia.

Y realmente no necesita el switch , el compilador lo optimizará en el código de máquina con una tabla de salto de puntero 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;
}
    
respondido por el Lundin

Lea otras preguntas en las etiquetas

Se necesita la identidad del componente electrónico Transmitir un flujo de video a través de un microcontrolador