Function pointers in FSM

HI.. I want an example of how to implement FSM using function poi开发者_JS百科nters in C.

See this simple example on how to implement a finite state machine in C.

An example is too big to write as an answer here. Here's an existing example, which I found by Googling for state machine c "function pointer": Implementing Efficient State Machines

Here is a little demo of using function pointers in ARDUINO. This example does not allow for concurrency. It perfectly transferable to normal C if make write the setup and loop inside main()
Each state is a void() function. Each state function is responsible for reading input and setting output. When this is done the function should return immediately. It will be called again directly. The function is also responsible for state-transition by calling the leave function immediately before returning. Each state function should have a static long variable for timekeeping.
A global variable state is set to point to the initial state in the setup routine. I wanted timekeeping in the different states so i implemented the state transitions by 2 functions:

void enter(long *stateTime), this should be called the very first thing when entering the state functions. It activates the state if inactive end keeps time.

void leave(void (*next)(), long *statetime), this changes the global state pointer and deactivates the current state.

void (*state)();//function pointer for state machine
long prevMillis = 0;//timekeeper
const int LEDPIN = 13;
int counter1 = 0;

void enter(long *statetime){
  if(*statetime==-1){//check for passive state
    prevMillis = millis();//set timemark when entering state
  }//if(statetime==0)
  *statetime = millis()-prevMillis;//keep time
}//enter()

void leave(void (*next)(), long *statetime){
  *statetime=-1;//set state to passive
  state=next;//point to next state
}//leave()

void off500ms(){
  static long stateMillis;//timer for this state
  enter(&stateMillis);//update timer
  digitalWrite(LEDPIN, LOW);
  if(stateMillis>499){//check if time is up
    leave(on500ms, &stateMillis);
  }//if(stateMillis>499)
}//off500ms()

void off2s(){
  static long stateMillis;//timer for this state
  enter(&stateMillis);//update timer
  digitalWrite(LEDPIN, LOW);
  if(stateMillis>1999){//check if time is up
    leave(on500ms, &stateMillis);
  }//if(stateMillis>499)
}//off2s()

void on500ms(){
  static long stateMillis;//timer for this state
  enter(&stateMillis);//update timer
  digitalWrite(LEDPIN, HIGH);
  if(stateMillis >499){//time is up
    if(++counter1==6){//number of blinks
      leave(off2s, &stateMillis);
      counter1=0;//reset counter
    }else{//if(++counter1==6)
      leave(off500ms, &stateMillis);
    }//if(++counter1==6)
  }//if(stateMills>499)
}//on500ms

void setup(){
  pinMode(LEDPIN, OUTPUT);
  state = on500ms;//set initial state
}/setup()

void loop(){
  state();//start FSM
}//loop  

I would say initialize a array of pointers to event handlers. So each element of a array is a function pointer to a particular event which is part of an enum. if foo is your array of function pointers which is initialized to event then call foo[event]() when any event occurs.

Try coding for calling a function pointer first, next you can move to array and come back to SO if there are more doubts.

For a start you can read about function pointers here.

State transtion code can be utilize either by array or switch case. Written under if else directive.

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

int entry_state(void);
int foo_state(void);
int bar_state(void);
int exit_state(void);

enum state_codes lookup_transitions(enum state_codes, enum ret_codes);

/* array and enum below must be in sync! */
int (* state[])(void) = { entry_state, foo_state, bar_state, exit_state};
enum state_codes { entry, foo, bar, end};

enum ret_codes { ok, fail, repeat};
struct transition {
    enum state_codes src_state;
    enum ret_codes   ret_code;
    enum state_codes dst_state;
};
/* transitions from end state aren't needed */
struct transition state_transitions[] = {
    {entry, ok,     foo},
    {entry, fail,   end},
    {foo,   ok,     bar},
    {foo,   fail,   end},
    {foo,   repeat, foo},
    {bar,   ok,     end},
    {bar,   fail,   end},
    {bar,   repeat, foo}};

int main(int argc, char *argv[]) {
    enum state_codes cur_state = entry;
    enum ret_codes rc;
    int (* state_fun)(void);

    for (;;) {
        state_fun = state[cur_state];
        rc = state_fun();
        if (end == cur_state)
            break;
        cur_state = lookup_transitions(cur_state, rc);
    }

    return EXIT_SUCCESS;
}

/*
 * lookup_transition() function has time complexity of class O(n).
 * We can optimize it.
 * */
enum state_codes
lookup_transitions(enum state_codes cur_state, enum ret_codes rc)
{
#if 0
    switch (cur_state) {
        case entry:
            cur_state = ((rc == ok) ? (foo) : (end));
            break;
        case foo:
            cur_state = ((rc == ok) ? (bar) : ((rc == fail) ? (end) : (foo)));
            break;
        default:
            cur_state = ((rc == ok) ? (end) : ((rc == fail) ? (end) : (foo)));
            break;
    }

    return cur_state;
#else
    char arr_size = (sizeof(state_transitions) / sizeof(state_transitions[0])); /* This can be shifted to main function to avoid redundant job. */
    char count;

    for (count = 0; count < arr_size; count++) {
        if ((state_transitions[count].src_state == cur_state) && (state_transitions[count].ret_code == rc)) {
            return (state_transitions[count].dst_state);
        }
    }
#endif
}

int entry_state(void)
{
    int st;
    enum ret_codes rc;

    printf("YOU ARE IN ENTRY STATE.\nEnter 0/1: ");

    scanf("%d", &st);

    rc = ((st == 1) ? (fail) : (ok));
    return rc;
}

int foo_state(void)
{
    int st;
    enum ret_codes rc;

    printf("YOU ARE IN FOO STATE.\nEnter 0/1/2: ");

    scanf("%d", &st);

    rc = ((st == 0) ? (ok) : ((st == 2) ? (repeat) : (fail)));
    return rc;
}

int bar_state(void)
{
    int st;
    enum ret_codes rc;

    printf("YOU ARE IN BAR STATE.\nEnter 0/1/2: ");

    scanf("%d", &st);

    rc = ((st == 0) ? (ok) : ((st == 2) ? (repeat) : (fail)));
    return rc;
}

int exit_state(void)
{
    printf("YOU ARE IN EXIT STATE.\n");

    exit(EXIT_SUCCESS);
}