Thread: Structs with a state machine

I'm working on making a state machine with a bunch of structs.

Each struct will contain things like
Number of Allowable state changes
What state changes are allowed
Timeout of current state
What state to change to when timeout occurs
Delay before state change happens
etc.

The control loop will have some sort of logic that is common to all the states and use a pointer to point to a different state struct.

Is this a common practice since I'm mostly seeing examples with a table and in my case I have a variable number of states I can jump to.

Why not make a small (runnable) example with three states to demonstrate what you mean?

This is a very simple example I got working.

I use the struct to keep track of what is a valid state jump and the memory location of that state. My real application is I have different states with different responses and timeouts. If it was more complicated I may have used function pointers, but I can just cycle through a loop as such with each state.

Yes I know there is memory cleanup, etc. I'm just getting the state machine concept down.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>


typedef enum State
{
    State1,
    State2,
    State3,
    StateNum}
State;


typedef struct StateData
{
    State CurrentState;
    int NumOfNextStates;
    State *PossibleNextStates;
    struct StateData **StatePtr;
    bool TimeoutFlag;
}StateData;


void State1CreateInit(StateData **s);
void State2CreateInit(StateData **s);
void State3CreateInit(StateData **s);


int main()
{
    //StateMachine[0] = malloc(sizeof(StateMachine));
    bool Quit = false;
    char sResp;
    StateData **StateMachine;
    StateData *CurrentState;


    StateMachine = malloc(StateNum * sizeof(*StateMachine));
    for(int i = 0; i < StateNum; i++)
    {
        StateMachine[i] = malloc(sizeof(*StateMachine[i]));
    }


    State1CreateInit(StateMachine);
    State2CreateInit(StateMachine);
    State3CreateInit(StateMachine);


    CurrentState = StateMachine[State1];


    while(!Quit)
    {
        printf("Current State is %d. Enter desired state:\n", CurrentState->CurrentState);
        sResp = getchar();


        for(int i = 0; i < CurrentState->NumOfNextStates; i++)
        {
            if(CurrentState->PossibleNextStates[i] == (sResp - '0'))
            {
                CurrentState = CurrentState->StatePtr[i];
                break;
            }
        }
        if(sResp == 'q')
            Quit = true;
    }


    return 0;
}


void State1CreateInit(StateData **s)
{
    s[State1]->CurrentState = State1;
    s[State1]->NumOfNextStates = 2;


    s[State1]->PossibleNextStates = malloc(s[State1]->NumOfNextStates * sizeof(*s[State1]->PossibleNextStates));
    s[State1]->StatePtr = malloc(s[State1]->NumOfNextStates * sizeof(*s[State1]->StatePtr));


    s[State1]->PossibleNextStates[0] = State2;
    s[State1]->PossibleNextStates[1] = State3;


    s[State1]->StatePtr[0] = s[State2];
    s[State1]->StatePtr[1] = s[State3];


    s[State1]->TimeoutFlag = false;


    return;
}


void State2CreateInit(StateData **s)
{
    s[State2]->CurrentState = State2;
    s[State2]->NumOfNextStates = 1;


    s[State2]->PossibleNextStates = malloc(s[State2]->NumOfNextStates * sizeof(*s[State2]->PossibleNextStates));
    s[State2]->StatePtr = malloc(s[State2]->NumOfNextStates * sizeof(*s[State2]->StatePtr));


    s[State2]->PossibleNextStates[0] = State3;


    s[State2]->StatePtr[0] = s[State3];


    s[State2]->TimeoutFlag = false;


    return;
}


void State3CreateInit(StateData **s)
{
    s[State3]->CurrentState = State3;
    s[State3]->NumOfNextStates = 1;


    s[State3]->PossibleNextStates = malloc(s[State3]->NumOfNextStates * sizeof(*s[State3]->PossibleNextStates));
    s[State3]->StatePtr = malloc(s[State3]->NumOfNextStates * sizeof(*s[State3]->StatePtr));


    s[State3]->PossibleNextStates[0] = State1;


    s[State3]->StatePtr[0] = s[State1];


    s[State3]->TimeoutFlag = false;


    return;
}

Algorism,

The timeout flag will be a timeout in ms. Some of the states ignore incoming messages for a period of time and then transition to another state.

In my real example I will be storing the message type, compare it to the incoming message and then transition to the correct state. I would need some lookup table in between to just use the index, which be easier to follow.

The va_arg seems to be a great way to cut down on the amount of code I have.