As máquinas de estado são um padrão de design comum em sistemas embarcados, e parece que você tem um caso de uso típico aqui. O que você pode fazer é simplesmente ter um loop infinito que permite que o estado atual manipule a mensagem recebida, faça a transição para um novo estado, se necessário, e espere um pouco.
Aqui está uma simples tentativa de C ++. No meu código, você precisa vincular ou registrar os possíveis estados de alguma forma, mas o interessante é que a parte realmente fixa (manipular evento, alternar para o próximo estado, se necessário) é realmente corrigida em subclasses.
Além disso, uma ótima vitória das máquinas de estado é que você pode verificar sua correção facilmente com uma combinação de revisão por pares, leitura cuidadosa de folhas de dados e alguns testes de unidade.
class State {
public:
// Forgetting constructors, etc.
// Assume event is an integer, could be tuned to your case
State *handleEvent(int event) {
switch (event) {
case EVENT1:
this->doAction1();
break;
// etc.
}
State *nextState = this->nextStateForEvent(event);
return nextState;
}
private:
// Force each subclass (= posisble state) to re-implement all these
virtual void doAction1() = 0;
// etc.
virtual State *nextStateForEvent(int event) = 0;
}
Em seguida, você obtém um loop principal que se torna algo assim:
#define DEFAULT_STATE 0
volatile int event = 0;
int main()
{
// Create the states beforehand
State *allStates = populate_the_possible_states;
State *currentState = allStates[DEFAULT_STATE];
while (1) {
currentState = currentState->handleEvent(event);
sleep(someMilliseconds);
}
}