Come fare le cose passo dopo passo

Le macchine a stati sono uno schema di progettazione comune nei sistemi embedded e sembra che tu abbia un tipico caso d'uso qui. Quello che puoi fare è semplicemente avere un ciclo infinito che consente allo stato corrente di gestire il messaggio in arrivo, passare a un nuovo stato se necessario, quindi attendere un po '.

Ecco una semplice prova in C ++. Nel mio codice, è necessario associare o registrare gli stati possibili in qualche modo, ma la cosa bella è che la parte veramente fissa (gestire l'evento, passare allo stato successivo se necessario) è veramente fissa nelle sottoclassi.

Inoltre, una buona vittoria delle macchine a stati è che puoi verificare facilmente la loro correttezza con una combinazione di revisione tra pari, lettura attenta del foglio dati e alcuni test di unità.

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;
}

Quindi, ottieni un loop principale che diventa qualcosa di simile a questo:

#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);
    }
}

Estratto sulla sua funzione, non stato. Gli Stati ricevono messaggi, fanno cose in risposta a quei messaggi e alterano lo stato di alcune variabili che sono persistenti negli stati.

I tuoi tentativi, timeout, stato successivo sono persistenti. Li inserivo in una sorta di gestore di tipo singleton, o semplicemente in alcune variabili statiche.

La funzionalità con lo stato è lasciata è cosa fare quando riceve un messaggio. Deve essere in grado di fare cose come cambiare le variabili statiche, eseguire funzioni basate su altre funzioni. Ecco un esempio a cui riesco a pensare, ma queste idee dovrebbero essere adattate a ciò che si desidera essere in grado di scrivere una volta che funzioni con tutti i diversi stati. Sono i loop di attesa? È il controllo per il comando di essere in una lista valida di comandi in base allo stato corrente? È in grado di tenere traccia delle sessioni?

public interface IState {
    void Process(string message);
}

Ora qualsiasi classe che crei può essere uno dei tuoi stati implementando questa interfaccia e aggiungendo un metodo Process (stringa) void alla classe.

public class PowerOn : IState {
    public void Process(string message) {
        powerOn();
        StateManager.NextStage = new ResetCmd();
        StateManager.AttemptsLeft = 5;
    }
}

public class ResetCmd : IState {
    public void Process(string message) {
        modem.write("ATZ\n");
        StateManager.AttemptsLeft--;
        StateManager.NextStage = new ResetReply();
        StateManager.Timeout = millis() + 5000;
    }
}

Sai come tutti dicono sempre che l'apprendimento di un linguaggio di programmazione funzionale può aiutarti in altre lingue, ma non sai mai esattamente come? Questo è uno di quei casi. A causa del modo in cui i linguaggi funzionali tracciano lo stato, hanno escogitato alcuni modi innovativi per eseguire attività di programmazione asincrone come le macchine a stati. Per usare questi pattern in C ++, probabilmente hai bisogno di C ++ 11 e / o boost.

Futures

I future sono un modo per specificare una sequenza di compiti asincroni, passando un valore da un passaggio all'altro, con percorsi diversi per il successo e l'insuccesso. Potresti estenderli per riprovare il comportamento che desideri. Una macchina di stato implementata usando i futures potrebbe sembrare qualcosa del tipo:

retryFuture(5)
.then(powerOn)
.then(resetCmd)
.then(attachNetwork)
.timeout(5000)
.failure(printFailureToScreen)

coroutine

Le Coroutine sono un modo per ordinare di interrompere una funzione nel mezzo e riprenderla dallo stesso punto in seguito, come quando viene ricevuta una risposta. È un tipo cooperativo di multitasking. Questo ti permette di specificare una funzione in un ordine più lineare.

powerOn()
yield
resetCmd()
yield
attachNetwork
yield

Attori

Gli attori sono un modo per fare passare il messaggio tra le attività in modo asincrono. Dovresti creare un attore per ogni fase della macchina a stati, quindi passare un messaggio al prossimo attore al momento opportuno. Questo è simile a quello che stai facendo ora con la variabile di stato, ma in un modo un po 'più strutturato.

Nessuna di queste idee può essere perfetta per la tua applicazione, ma spero che ti dia una spinta in una direzione per trovare una combinazione che potrebbe essere utile per te.

Se vuoi semplicemente passare dall'uso di una macchina basata su switch, ti consiglio una tecnica che ho imparato a scuola, che divide la macchina in 3 o 4 funzioni ortogonali:

• Una funzione di determinazione dello stato successivo - questo richiederebbe lo stato corrente della macchina e il suo input corrente e determinerebbe quale dovrebbe essere il successivo stato della macchina, restituendo ciò (senza effetti collaterali)
• Una funzione di output di transizione - questo dovrebbe esaminare quale transizione di stato è stata presa, insieme con l'input, e reagire ad essa (paragonabile all'output di una macchina Mealy, in esecuzione solo quando si verifica una transizione)
• Una funzione di output di stato - questo dovrebbe guardare lo stato corrente e l'output per esso (paragonabile all'output di una macchina Moore, in esecuzione su ogni iterazione del loop della macchina)
• Una funzione di transizione: chiama le altre tre funzioni e imposta lo stato della macchina

(Questo è copiato da la mia risposta qui - c'è un esempio di codice anche lì se vuoi un esempio.)

Tuttavia potresti considerare una macchina completamente OOP. Ci sono pacchetti software che ti permetteranno di creare diagrammi e generare il codice per loro, il che dovrebbe ridurre la noia di implementare una macchina a stati.

Se non sei sicuro di quale livello utilizzare, ho integrato con successo un approccio OOP dall'approccio della funzione.

Alcuni dei tuoi requisiti mi hanno fatto pensare a macchine di stato gerarchiche (potresti voler iniziare a leggere al precedente sottosezione), quindi potresti verificarlo.