Lecture 12

E21 Computer Engineering Fundamentals

Author

Emad Masroor

Published

October 8, 2026

Test 2 Discussion

  • Mean: 22.4
  • Median: 23

Combination Lock — Review

Run the following code to implement a FSM for a 4-step combination lock on the Circuit Playground Express.

Press some combination of A and B to unlock your device. All four lights green = unlocked!

from adafruit_circuitplayground.express import cpx
import time

state = 1

def wait_till_release_A():
    while cpx.button_a:
        print("release button to complete transition")
        time.sleep(0.5)
def wait_till_release_B():
    while cpx.button_b:
        print("release button to complete transition")
        time.sleep(0.5)

while True:
    time.sleep(0.05)
    # Define what each state looks like
    if state == 1:
        # Locked state
        for k in range(0,4):
            cpx.pixels[k] = (50,0,0)
    elif state == 2:
        # One correct entry
        for k in range(1,4):
            cpx.pixels[k] = (50,0,0)
        cpx.pixels[0] = (0,50,0)
    elif state == 3:
        # Two correct entry
        for k in range(2,4):
            cpx.pixels[k] = (50,0,0)
        for k in range(0,2):
            cpx.pixels[k] = (0,50,0)
    elif state == 4:
        # Three correct entry
        cpx.pixels[3] = (50,0,0)
        for k in range(0,3):
            cpx.pixels[k] = (0,50,0)
    elif state == 5:
        # Four correct entry -- unlocked !
        for k in range(0,4):
            cpx.pixels[k] = (0,50,0)
            
    if state == 1:
        if cpx.button_a:
            state = 2
            print("Button A pressed! moving from state 1 to state 2")
            wait_till_release_A()
        elif cpx.button_b:
            state = 1
            print("Button B pressed! moving from state 1 to state 1")
            wait_till_release_B()

    if state == 2:
        if cpx.button_a:
            state = 1
            print("Button A pressed! moving from state 1 to state 2")
            wait_till_release_A()
        elif cpx.button_b:
            state = 3
            print("Button B pressed! moving from state 1 to state 1")
            wait_till_release_B()

    if state == 3:
        if cpx.button_a:
            state = 1
            print("Button A pressed! moving from state 1 to state 2")
            wait_till_release_A()
        elif cpx.button_b:
            state = 4
            print("Button B pressed! moving from state 1 to state 1")
            wait_till_release_B()
    
    if state == 4:
        if cpx.button_a:
            state = 5
            print("Button A pressed! moving from state 1 to state 2")
            wait_till_release_A()
        elif cpx.button_b:
            state = 1
            print("Button B pressed! moving from state 1 to state 1")
            wait_till_release_B()

Draw the state transition diagram for this

State Transition Diagram for lock

ABBA opens the lock

Figure 1

State Transition Tables

Table 1
State Input:
A		 Input:
B
Locked 1 Correct Locked
1 Correct Locked 2 Correct
2 Correct Locked 3 Correct
3 Correct Unlocked Locked
Unlocked Unlocked Unlocked
  • State transition tables are an alternative to state transition diagrams for showing how a Finite State Machine works
  • Each row corresponds to a possible current state of the system.
  • Each column corresponds to a possible input to the system.
  • Each entry corresponds to the new state that results.

Engineering Specifications to Finite State Machines

  • The combination lock system is described by Table 1, Figure 1, Figure 3
  • Implement a new engineering specification:
    • After unlock, any key should light all four LEDs blue.
    • Any further key press should ‘lock’ it again.
  • Add new entries to the state-transition table and modify the code to meet this specification.
Figure 2: Finite State Machine before changes applied

Modified Lock FSM

To accommodate the new specifications:

  • Create a new state and add it to the table

    State Input:
    A    		 Input:
    B
    Locked 1 Correct Locked
    1 Correct Locked 2 Correct
    2 Correct Locked 3 Correct
    3 Correct Unlocked Locked
    Unlocked Ready Ready
    Ready Locked Locked
Figure 3: Finite State Machine after changes applied

Truth Tables for Finite State Machines

  • A FSM can also be expressed as a truth table
  • Need an encoding of the states and inputs using 0 and 1.
  • Let’s use a simply FSM with one binary state variable and one binary input: the retractable ball point pen.
  • States: Nib out (1), Nib retracted (0)
  • Input: Press button (1), Don’t press button (0)
Table 2: Truth Table for Finite State Machine representing retractable pen
State Input New State
0 0 0
0 1 1
1 0 1
1 1 0

Logic Gates for Finite State Machines

A AND B is True if and only if both A and B are True

NOT A is True if and only if A is False.

A OR B is True if and only if either A or B (or both) are True

These three logic gates can be used to implement truth tables, and therefore Finite State Machines

Implementing a Truth Table using Logic Gates

State Input New State
0 0 0
0 1 1
1 0 1
1 1 0

Truth Tables for systems with more than 4 state-input combinations

Let’s return to the 4-step combination lock.

State Input:
A		 Input:
B
Locked 1 Correct Locked
1 Correct Locked 2 Correct
2 Correct Locked 3 Correct
3 Correct Unlocked Locked
Unlocked Ready Ready
Ready Locked Locked

To get a truth table for this, we:

  • Encode each state as a binary number. Locked: 000. 1 Correct: 001. 2 Correct: 010. 3 Correct: 011. Unlocked: 100. Ready: 101.
  • Encode each input as a binary number: A = 0 and B = 1
  • The choice of encoding is arbitrary, but will determine what the truth table looks like.

Truth Table for combination lock ABBA

State Input New State
000 0 001
000 1 000
001 0 000
001 1 010
010 0 ?
010 1 ?
011 0 ?
011 1 ?
100 0 101
100 1 101
101 0 000
101 1 000
State Input A
0		 Input A
1
◯ ◯ ◯ ◯ ✓ ◯ ◯ ◯ ◯ ◯ ◯ ◯
✓ ◯ ◯ ◯ ◯ ◯ ◯ ◯ ✓ ✓ ◯ ◯
✓ ✓ ◯ ◯ ◯ ◯ ◯ ◯ ✓ ✓ ✓ ◯
✓ ✓ ✓ ◯ ✓ ✓ ✓ ✓ ◯ ◯ ◯ ◯
✓ ✓ ✓ ✓ Ready Ready
Ready ◯ ◯ ◯ ◯ ◯ ◯ ◯ ◯

Definitions:

State Encoding Meaning
◯ ◯ ◯ ◯ 000 Locked
✓ ◯ ◯ ◯ 001 1 down
✓ ✓ ◯ ◯ 010 2 down
✓ ✓ ✓ ◯ 011 3 down
✓ ✓ ✓ ✓ 100 Unlocked
Ready 101 Ready

Fill in the new state column

A simple Finite State Machine: Building its State Transition Table

  • Let’s build the state-transition table for this FSM.
  • Naming convention: \(S_1\) is 0, \(S_2\) is 1.
State Input 0 Input 1
0 1 0
1 1 0

A simple Finite State Machine: Building its Truth Table

  • Let’s build the truth table for this FSM.
  • Naming convention: \(S_1\) is 0, \(S_2\) is 1.
State Input New State
0 0 1
0 1 0
1 0 1
1 1 0

A simple Finite State Machine: Implementing it with Logic Gates

State (A) Input (B) New State
0 0 1
0 1 0
1 0 1
1 1 0

Draw a logic-gate diagram for this truth table using AND OR and NOT

Strategy:

  • Look for a combination of and, or and not statements that describe the new state column in terms of the other two columns.

  • Write out a boolean statement in words.

    New State is 1 if State and Input are both 0, or if State is 1 and Input is 0.

  • Write down the conditions needed for New State to be 1.

    = (not A and not B) or (A and not B).

  • Otherwise, New State is assumed to be 0 because of the law of excluded middle

Summary

We have learned four different ways of representing a Finite State Machine:

  1. State transition diagram
  2. State transition table
  3. Truth table
  4. Logic gates diagram