Chapter 10: C Structures

Projects

Finite State Machine

I initially thought about naming this section “Finite State Machines, Lions, Tigers, and Bears… Oh My!” because the topic seems a bit scary. And I must admit that there are graduate level Computer Science courses taught on this subject, so it can get very scary indeed. But, fortunately for us, the fundamental concepts that we will use are fairly easy to grasp, and we don’t need to go to great depths to get what we need.

The basic ideas behind finite state machines are used to tame systems that seem impossibly complex. A computer is a finite state machine. At any given moment the computer state is defined by a bunch of transistor states, off or on, 0’s and 1’s. The computer inputs a set of 0’s and 1’s, from some external source, checks its current state and changes both the current state and the output state based on the current state and the input state.

Actually you and I can be seen as state machines. Right now my state is ‘typing’. If my ears input the sound of a screeching tiger my state will change to ‘running like hell.’ And, if my ‘running like hell’ state isn’t >= the tigers ‘running like hell’ state, my future state may sequence through ‘being lunch’, being digested’, and ‘being tiger poop.’

When you think about it, the Butterfly, as simple as it is, does a lot of stuff. How does the software keep track of what it is doing? How does it know to keep doing it? How does it know when to do something different? And how does it know what to do next?

Say the Butterfly is outputting a value on PORTD and you diddle the joystick, how does it respond to being diddled? You may recall this switch statement from Chapter 5.

switch(input){

case KEY_PLUS : PORTD = ~0x01; break:

251

Chapter 10: C Structures

case KEY_NEXT : PORTD = ~0x02; break;

case KEY_PREV : PORTD = ~0x04; break;

case KEY_MINUS : PORTD = ~0x08; break;

case KEY_ENTER : PORTD = ~0x10; break;

default:

}

This is a state machine. The current state is the value of PORTD. The input is the joystick position. The case statement for the specific joystick input sets the next state in PORTD. If this switch statement is enclosed in a for(;;){}block, the Butterfly’s states and transitions are all known, so the possibilities are finite and you have yourself a finite state machine. What could be simpler? (Usually said right before things get complex.)

But, of course, the Butterfly out of the box does a lot of stuff. And it has a lot of state machines controlling its behavior. One is the menu state machine, which is really the core state machine as far as a user is concerned. Here is an illustration of the Butterfly menu structure:

252

Chapter 10: C Structures

Figure 39 Butterfly Menu

253

Chapter 10: C Structures

At one moment the Butterfly may be scrolling the LCD with your name. Then you click the joystick down and it shows you the time. It needs to keep some sort of data set that contains what it is doing now and how to react to inputs and what to do next based on what is doing now.

We can think about input stimulated state transitions like this:

If I am doing A_state and

if A_input happens, then I enter Q7_state

else if B_input happens, then I enter YM_state else if C_input happens, then I enter X15_state // and so on

else if XXX_input happens, then I enter Mental_state If I am doing B_state and

if A_input happens, then I enter B_state else if B_input happens, then I enter A_state else if C_input happens, then I enter Y_state // and so on

and XXX_input happens, then I enter Pros_state // and so on

If I am doing XXX_state and

if A_input happens, then I enter Alpha_state else if B_input happens, then I enter Beta_state

else if C_input happens, then I enter Gamma_state // and so on

else if XXX_input happens, then I enter Tennessee_state

From the Butterfly menu we see that we can do this like:

If I am showing “AVR Butterfly” on the LCD and

if the joystick is clicked left, then I enter the Revision state else if the joystick is clicked down, then I enter the Time state

If I am showing the “Time” on the LCD and

if the joystick is clicked left, then I enter the Clock state

else if the joystick is clicked down, then I enter the Music state // and so on

If I am showing “Options” on the LCD and

254

Chapter 10: C Structures

if the joystick is clicked left, then I enter the Display state

else if the joystick is clicked down, then I enter the AVR Butterfly

state

For each state, we must know the next state that we must enter for each possible input state. That’s going to be a lot of data so lets use what we’ve learned about structures to keep track of it. First we define two generic structures that we will later instantiate for each specific state, input, and next state data set.

[ASIDE: As mentioned before, the Butterfly software was written using an IAR compiler and ported to the Win AVR complier. There are a lot of notes in the code that begin // mt. This is a note added by Martin Thomas who did the porting. Kudo’s to Martin, but I’ve removed his notes from the discussion as they are not relevant to what we are trying to learn here.]

In Menu.h we find the definitions of data structures for our menu state and menu next state that contains the three relevant variables:

typedef struct PROGMEM

{

unsigned char state; // the current state

PGM_P pText; // pointer to some text in FLASH memory char (*pFunc)(char input); // pointer to a function

} MENU_STATE;

typedef struct PROGMEM

{

unsigned char state; // the current state unsigned char input; / the input stimulus

unsigned char nextstate; // the resulting next state } MENU_NEXTSTATE;

The MENU_STATE structure provides the data we need to find the function that should be run while in the specified state. The MENU_NEXTSTATE structure provides the data we need to find the next state given the present state and an input state.

Let’s deal with the MENU_STATE structure first. We see that we can have 256 states, and can associate a text name and a function pointer with each. The function pointer is defined as taking a character input value and returning a

255

Chapter 10: C Structures

character to the caller. We define an array of instances of this structure in Menu.h as follows:

You will note in the table that each state has either a state text or a state function defined, but not both, that complication will be explained later.

For the MENU_NEXTSTATE structure we also have 256 possible states, and 256 possible inputs for each state, and 256 possible next states for all those, that’s 65536 possible state transitions for each state, fortunately we won’t need that many. We define an array of instances of this structure in Menu.h as follows:

const MENU_NEXTSTATE menu_nextstate[] PROGMEM = {

We can use this as:

256

Chapter 10: C Structures

We can search this array of structures to find out what we need to do if we are in the ST_AVRBF state and the input is KEY_NEXT, we find that particular structure and see that the next state is ST_AVRBF_REV. Now all we have to do is find out what we need to do if our next state is ST_AVRBF_REV, which we can do by searching the menu_state array to find the ST_AVRBF_REV entry. We see that there is a function defined for this state, and equate the function pointer to it. Then we can call that function.

Clear so far?

The main() function slorps into an infinite loop, part of which, depending on the state, is used to search the menu_state array. The following code snippit compares the present state with the next state [if (nextstate != state)] and, being very reasonable, does nothing if they are the same. If the states differ, main() sets the global state variable to the nextstate variable and then accesses the menu_state structure array to change the current state to the next state.:

if (nextstate != state)

{

state = nextstate;

for (i=0; pgm_read_byte(&menu_state[i].state); i++)

{

if (pgm_read_byte(&menu_state[i].state) == state)

{

statetext =(PGM_P)pgm_read_word(&menu_state[i].pText); pStateFunc = (PGM_VOID_P)pgm_read_word(&menu_state[i].pFunc); break;

}

}

}

Since we took ST_AVRBF_REV to be the next state, so searching the array causes the snippet to make the function pointer, pStateFunc, point to the Revision function.

257

Chapter 10: C Structures

Whoa, there I was clicking right along and suddenly, I lost it; maybe its time to review what I’ve said so far?

•We have two data structures, one for storing the text and function associated with a state and one for finding the next state given the current state and the input.

•We have two structure arrays, one for each of the structures, which define all the states and transitions.

•We have code for searching each of these arrays. One finds the function associated with a given state and the other finds the next state to use given the current state and the inputs.

Now how should we use this? We could sit in an infinite loop checking the inputs and then looking at the current state and seeing if a transition to a new state is called for. Hey, sounds like a plan. We could write our main() function as follows, hopefully commented to crystal clarity:

unsigned char state; // holds the current state, according to “menu.h”

int main(void)

{

//Define our local copies of the state variables unsigned char nextstate;

PGM_P statetext;

char (*pStateFunc)(char); char input;

//Define a loop counter

uint8_t i; // char i;

// Initial state variables state = nextstate = ST_AVRBF; statetext = MT_AVRBF; pStateFunc = NULL;

for (;;) // Main loop

{

// read the joystick buttons input = getkey();

258

Chapter 10: C Structures

if (pStateFunc) // If a state function is pointed to

{

//When a state function is pointed to, we must call it

//and get the results as the nextstate variable nextstate = pStateFunc(input);

}

else if (input != KEY_NULL) // If not, and input not NULL

{

//We call the StateMachine function to examine the

//MENU_NEXTSTATE array to find the nextstate nextstate = StateMachine(state, input);

}

// Now we know what the next state is

if (nextstate != state) // Do only if the state has changed

{

state = nextstate; // The state changed, so reset it

//Read the MENU_STATE array until we find the entry

//matching the current state

for (i=0; pgm_read_byte(&menu_state[i].state); i++)

{

// If we find the entry

if (pgm_read_byte(&menu_state[i].state) == state)

{

//We load the state variables from that entry statetext =(PGM_P)pgm_read_word(&menu_state[i].pText); pStateFunc

=(PGM_VOID_P)pgm_read_word(&menu_state[i].pFunc);

//And we exit the loop

break;

}

// If we found an entry for the pStateFunc, we now loop

back

// to the top were we run it.

}

}

}//End Main loop return 0;

}

Of course, the actual Butterfly main() function does a lot of other stuff, but this should help you understand the menu state machine part.

259

Chapter 10: C Structures

I know, believe me I know. This is hard stuff, but you should be able to walk through the Butterfly state machine code now and fully understand how it works. If you don’t… well, maybe you want to back up to the pointers section and read slowly till you are back here again. Don’t feel bad, C takes a while to get used to and the guys who wrote the Butterfly software have very long, cold, and dark winters to hunker down with little else to do other than get used to C programming, well, there are the Reindeer…

260