State Machines in Python

State machines are a pretty popular design pattern for designing reliable systems.  The general concept is that you have a system which is in one particular state at a time. The state a system is in should completely describe the system; i.e. a system should not have storage that isn't represented by the state.

State transitions occur in response to events. The system can only change states when an event occurs that makes it change. After the transition, the system will remain in the new state until an event occurs that causes it to move to another state.

The nice thing about state machines is that you can very easily make a diagram explaining the complete logic of your system, and then implement this diagram in code without making errors. And you have an easy way to break down the logic and look for errors. It's easy to instrument events and state transitions.

In C, it is very common to make the states and events be enums. Then your state transition logic can be handled by switch/case constructs.

so you'd likely have:

typedef enum State{
INIT = 0;
GO_FORWARD = 1;
GO_BACK =2;
TURN_LEFT = 3;
TURN_RIGHT =4;
} State;

typedef enum Event{
None  = -1;
Init_Done =0;
Hit_Wall =1;
Left_Key = 2;
Right_Key =3;
Timer_Done= 4} Event;

And then your state machine would be something like:

while(1)
event = checkForEvents();
switch state{
case INIT:
if (event == Init_Done)
    state = enterState(GO_FORWARD);
break;
case GO_FORWARD:

And so on. There are other ways to organize it--you could switch on the event for example.


Now of course Python doesn't have switch and it doesn't have enum. There are a lot of kludges for both, most contained within stackexchange reponses to frustrated C programmers. We could of course combine a kludgy enum with a kludgy switch.

If you're a shitty programmer like me, this is what you end up with at first cut:

class StateEnum():
    _vals=['no_change','Init','WaitLong','Acquired','WaitL','WaitR','ScanL','ScanR']
    def __init__(self,val):
        if self._vals.__contains__(val):
            self.val = val
        else:
            raise ValueError
    def __str__(self):
        return self.val
    def __eq__(self,y):
        return self.val == y

And down in our loop:

       while(self.runSM.isSet()):
            if self.state == StateEnum('Init'):
                event = EventEnum('done_init')
            elif self.state == StateEnum('WaitLong'):
                if self.hasFace:
                    event = EventEnum('Acquired')
                if self.timer[0]:
                    if self.timer[1] < time.time():
                        event=EventEnum('DoneTimer')
                else:
                    RuntimeError
            elif self.state == StateEnum('Acquired'):
                if self.hasFace:
                    cx = self.pidx.update(self.errx)
                    self.yaw = self.yaw - cx
                    self.servo.setyaw(self.yaw)
                    self.errx_last = self.errx
                    cy = self.pidy.update(self.erry)
                    self.pitch = self.pitch - cy
                    self.servo.setpitch(self.pitch)
                    self.erry_last = self.erry
                   else:
                    if self.errx_last <= 0:
                        event=EventEnum('LostL')
                    if self.errx_last > 0:
                        event=EventEnum('LostR')
            elif (self.state == StateEnum('WaitL')) or (self.state == StateEnum('WaitR')):
                self.yaw = self.yaw - cx
                self.servo.setyaw(self.yaw)
                cx=cx/2
                self.pitch = self.pitch - cy
                self.servo.setpitch(self.pitch)
                cy=cy/2
                if self.hasFace:
                    event = EventEnum('Acquired')
                if self.timer[0]:
                    if self.timer[1] < time.time():
                        event=EventEnum('DoneTimer')
                else:
                    RuntimeError
# (and so on)

Yeah, this is pretty horrible. Note that that i'm combining event checking and state transition logic, and that I have to use string compares to compare states, and that really everything is just a giant mess of elifs.


Next: A better way to do things!