# Please use Python to answer this question

10.4. An example: state machines

A state machine is a system that can be in one of a few different states. We draw a state diagram to represent the machine, where each state is drawn as a circle or an ellipse. Certain events occur which cause the system to leave one state and transition into a different state. These state transitions are usually drawn as an arrow on the diagram.

This idea is not new: when first turning on a cellphone, it goes into a state which we could call Awaiting PIN. When the correct PIN is entered, it transitions into a different state say Ready. Then we could lock the phone, and it would enter a Locked state, and so on.

A simple state machine that we encounter often is a traffic light. Here is a state diagram which shows that the machine continually cycles through three different states, which weve numbered 0, 1 and 2.

Were going to build a program that uses a turtle to simulate the traffic lights. There are three lessons here. The first shows off some different ways to use our turtles. The second demonstrates how we would program a state machine in Python, by using a variable to keep track of the current state, and a number of different if statements to inspect the current state, and take the actions as we change to a different state. The third lesson is to use events from the keyboard to trigger the state changes.

Copy and run this program. Make sure you understand what each line does, consulting the documentation as you need to.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

import turtle # Tess becomes a traffic light. turtle.setup(400,500) wn = turtle.Screen() wn.title("Tess becomes a traffic light!") wn.bgcolor("lightgreen") tess = turtle.Turtle() def draw_housing(): """ Draw a nice housing to hold the traffic lights """ tess.pensize(3) tess.color("black", "darkgrey") tess.begin_fill() tess.forward(80) tess.left(90) tess.forward(200) tess.circle(40, 180) tess.forward(200) tess.left(90) tess.end_fill() draw_housing() tess.penup() # Position tess onto the place where the green light should be tess.forward(40) tess.left(90) tess.forward(50) # Turn tess into a big green circle tess.shape("circle") tess.shapesize(3) tess.fillcolor("green") # A traffic light is a kind of state machine with three states, # Green, Orange, Red. We number these states 0, 1, 2 # When the machine changes state, we change tess' position and # her fillcolor. # This variable holds the current state of the machine state_num = 0 def advance_state_machine(): global state_num if state_num == 0: # Transition from state 0 to state 1 tess.forward(70) tess.fillcolor("orange") state_num = 1 elif state_num == 1: # Transition from state 1 to state 2 tess.forward(70) tess.fillcolor("red") state_num = 2 else: # Transition from state 2 to state 0 tess.back(140) tess.fillcolor("green") state_num = 0 # Bind the event handler to the space key. wn.onkey(advance_state_machine, "space") wn.listen() # Listen for events wn.mainloop()

The new Python statement is at line 46. The global keyword tells Python not to create a new local variable for state_num (in spite of the fact that the function assigns to this variable at lines 50, 54, and 58). Instead, in this function, state_num always refers to the variable that was created at line 42.

What the code in advance_state_machine does is advance from whatever the current state is, to the next state. On the state change we move tess to her new position, change her color, and, of course, we assign to state_num the number of the new state weve just entered.

Each time the space bar is pressed, the event handler causes the traffic light machine to move to its new state.

#####################################################################################

1. Change the traffic light program (at the top) so that changes occur automatically, driven by a timer.

2. In an earlier chapter we saw two turtle methods, hideturtle and showturtle that can hide or show a turtle. This suggests that we could take a different approach to the traffic lights program. Add to your program above as follows: draw a second housing for another set of traffic lights. Create three separate turtles to represent each of the green, orange and red lights, and position them appropriately within your new housing. As your state changes occur, just make one of the three turtles visible at any time. Once youve made the changes, sit back and ponder some deep thoughts: youve now got two different ways to use turtles to simulate the traffic lights, and both seem to work. Is one approach somehow preferable to the other? Which one more closely resembles reality i.e. the traffic lights in your town?

3. Now that youve got a traffic light program with different turtles for each light, perhaps the visibility / invisibility trick wasnt such a great idea. If we watch traffic lights, they turn on and off but when theyre off they are still there, perhaps just a darker color. Modify the program now so that the lights dont disappear: they are either on, or off. But when theyre off, theyre still visible.

4. Your traffic light controller program has been patented, and youre about to become seriously rich. But your new client needs a change. They want four states in their state machine: Green, then Green and Orange together, then Orange only, and then Red. Additionally, they want different times spent in each state. The machine should spend 3 seconds in the Green state, followed by one second in the Green+Orange state, then one second in the Orange state, and then 2 seconds in the Red state. Change the logic in the state machine.

State 0 State 1 State 2 State 0 State 1 State 2