Homework:  

Simple State Machine – Traffic Light 

 

 

Introduction 

To  practice  using  the  state  machine  design  pattern,  you  can  create  a  simple  program  that 
controls a single traffic light – switches the lights on and off in the well-known sequence:  

red → red and yellow → green → yellow → red... 

and so on. 

 

Front Panel – User Interface 

First, you need a traffic light – place three round LEDs on the front panel and set them the 
right colours (for example, right-click an LED, go to Properties » Appearance tab and select 
the desired colours). Next, to make the code easier to understand, change the labels of the 
LEDs – for example, to Red, Yellow and Green. You can hide the labels from the front panel 
by right-clicking an LED and unchecking the option Visible Items » Label. (You can select all 
LEDs  at  once  and  change  label  visibility  for  all  of  them  simultaneously  –  then  you  will  not 
need to repeat the process three times.)  

When you finish, the traffic light should look similar to what is in the pictures:  

   LEDs off                        

   LEDs on 

 

 

Block Diagram – Application Code 

On the block diagram, create a state machine. Let's consider which states are needed:  



 

red light on 



 

yellow light on 



 

green light on 



 

red and yellow lights on.  

Each state should last a certain amount of time, and then the  traffic light should switch to 
the next state.  

You could also add a separate fifth state – application stop. However, to keep the program 
simple  we  are  going  to  have  only  the  above-mentioned  four  states,  and  the  VI  will  be 
stopped simply with a STOP button wired to the conditional terminal of the While Loop.  

Now you can move on to writing the code for the state machine. For this, you need a While 
Loop  with  a  Case  Structure  inside,  and  something  that  you  will  wire  to  the  Case  Selector 
terminal of the Case Structure (the one with the question mark '?'). This "something" might 
be an integer and the program may move from state "1" to "2", from "2" to "3" and so on, 
but that would not be very clear. You could also use strings and label your states with words 
"Green", "Yellow" etc. – such approach results in much clearer code but you have to be very 
careful with spelling. If you tell your program to go to "Yellw" state instead of "Yellow", it will 
probably  behave  in  a  strange  way  and  you  will  waste  time  debugging  it.  Thus,  the  best 
option seems to be using an enum with four items – one for each state.  

Create  a  shift register  on  the  border of the  While  Loop  and  wire  a  constant  of  your  enum 
through the shift register to the Case Selector terminal. Set the value of the constant to the 
state which you want to be the start state of the traffic light – for example, the red light:  

 

According to what we have said about type definitions – it should come to your mind now to 
make  this  enum  a  type  definition.  In  each  state  of  the  state  machine  we  have  to  tell  the 
program which state to go to next, so we need more enum constants and each of them has 
to  have  the  same  item  list  as  the  "initial  state"  constant.  In  case  we  want  to  modify  the 
enum  in  the  future,  it  is  a  good  idea  to  save  it  as  type  definition:  right-click  the  enum 
constant  that  initializes  the  shift  register  and  select  Make  Type  Def.,  then  right-click  the 
constant again, choose Open Type Def. and save it to a file.  

After  you  create  a  type  definition,  a  triangular  mark  appears  in  the  corner  of  the  enum 
constant:  

 

Now  you  can  define  to  which  state  to  go  from  which.  In  our  application  this  logic  is  quite 
simple. Create a separate case of the Case Structure for each value of the enum (right-click 
Case Structure border and select Add Case for Every Value); then, insert a constant (a copy 
of  the  "red"  enum  constant)  into  each  case  and  set  the  proper  value  in  it.  Wire  these 
constants through a tunnel on the Case Structure to the right-side part of the shift register:  

 

 

 

 

 

This way you created the whole logic of the architecture of the state machine – you defined 
all state transitions. Now it is time to add the code which will define the actions performed 
in each state. 

We want every case of the Case Structure to switch certain lights on and off – thus, the LEDs' 
terminals  should  be  placed  inside  the  loop,  but  outside  of  the  Case  Structure.  From  the 
inside of each case, True and False values should only be sent through tunnels to the LEDs. 
For example, in the state that turns the green light on it will look like this:  

 

Other states should be completed in a similar way.  

In the end, you need every light to be turned on long enough, that is – you need each state 
to last a certain amount of time. You can use Wait function for it. The first option is to make 
all states last equally long, and add a Wait function with the desired amount of milliseconds 
wired to it outside the Case Structure:  

 

The  second  option,  more  similar  to  the  real  traffic  lights,  is  to  have  the  possibility  to  set 
different  time  durations  for  different  states.  To  accomplish  this,  wire  a  separate  constant 
with the amount of milliseconds from each state, through a tunnel, to the Wait function: 

 

The program is finished – you can test it now! 

 

End note 

You will probably notice that sometimes you need to wait quite long for the VI to react to 
your pressing the STOP button. This is because there is a high value of milliseconds wired to 
the Wait function inside the loop. After you press the STOP button, you need to wait for the 
current  state  to  finish  execution  (that  is,  you  need  to  wait  for  the  given  amount  of 
milliseconds to elapse) and only then LabVIEW reads the STOP control and stops the loop. To 
make  the  program  respond  faster  to  pressing  the  STOP  button,  the  state  machine  would 
have to be written a bit differently to enable wiring a smaller constant to the Wait function; 
this  would  make  the  VI  more  complicated,  so  we  are  not  going  to  do  this  in  this  simple 
program, which is perhaps your first state machine ever.  

If  you  feel  comfortable with  the  idea  of  state  machines,  you  can  try  to make  such  a  more 
advanced (more responsive) version of the traffic light on your own. Good luck!