Activity 2.14: Sense and Decide

Motion & Autonomy — Day 4 of 4

Activity 2.14

Sense and Decide

Key Concepts

The Control Loop

Tuning by Testing

Guarding a Sentinel

Nothing New Today

No new components. No new functions from the library. Every piece of this activity you have already built.

Today you join them — and that turns a machine that obeys into one that decides.

Three Steps, Forever

while True:
    cm = read_distance()      # SENSE
    if cm < STOP_CM:          # DECIDE
        stop()                # ACT
    else:
        drive(SPEED, SPEED)

Sense, decide, act. Round and round, many times a second. This shape runs thermostats, cruise control, elevators, and every robot you have ever seen.

Look at That Code Again

It has a bug. Not a typo — a reasoning bug, and it comes from something you built deliberately last session.

cm = -1        # nothing in range

-1 < 20        # True. Which is not what you meant.

-1 means nothing in range. An empty corridor. And -1 is less than 20, so the robot stops dead in front of wide open space.

Guard the Sentinel

if cm > 0 and cm < STOP_CM:

A sentinel value is only safe while every comparison remembers it exists. Yours is negative for exactly this reason — one extra test separates close from unknown.

Then There Are the Numbers

How close is too close? How long should it reverse? How far should it turn?

Nothing tells you. You pick something, run the robot, watch it fail, and change it — the same method you used to choose a threshold in 2.10, now with four numbers instead of one.

Today's Objectives

Combining a sensor reading and a motor command in one loop
Writing an obstacle-avoidance behavior
Guarding against an out-of-range reading
Tuning thresholds and timings by testing rather than guessing

Key Terms

Control Loop: Sense, decide, act, repeated indefinitely. The basic shape of every automatic machine.
Autonomous: Choosing what to do from its own sensor readings, with nobody steering.
Tuning: Adjusting numbers by testing, because no reference tells you the right values.
Guarding: Checking a value is real before comparing it, so a sentinel is not mistaken for a measurement.

'F' → Fullscreen

Build

Everything stays wired from 2.12 and 2.13. Create a new MicroPython program named 2-14-rover.

Work on the floor, not the desk. The robot moves on its own from Task 1 onward.

Task 1: Sense and Stop

Bring your drive(), stop() and read_distance() functions into one script.
Drive forward while the way is clear, and stop when something is closer than STOP_CM.
Walk toward the robot and watch it stop.

Note the cm > 0 in the condition. Without it, an out-of-range reading of -1 counts as "too close" and the robot refuses to move in an empty room. Try removing it once, deliberately, so you have seen it happen.

[PHOTO PLACEHOLDER — Task 1: Rover Stopping in Front of an Obstacle]

1
from machine import Pin, PWM, time_pulse_us
2
import time
3

4
a_in1 = Pin(31, Pin.OUT)
5
a_in2 = Pin(32, Pin.OUT)
6
a_pwm = PWM(Pin(33))
7
a_pwm.freq(1000)
8

9
b_in1 = Pin(21, Pin.OUT)
10
b_in2 = Pin(35, Pin.OUT)
11
b_pwm = PWM(Pin(34))
12
b_pwm.freq(1000)
13

14
trigger = Pin(22, Pin.OUT)
15
echo = Pin(20, Pin.IN)
16

17
SPEED = 40000
18
STOP_CM = 20
19
TIMEOUT_US = 30000
20

21

22
def motor(in1, in2, pwm, speed):
23
    if speed > 0:
24
        in1.value(1)
25
        in2.value(0)
26
        pwm.duty_u16(speed)
27
    elif speed < 0:
28
        in1.value(0)
29
        in2.value(1)
30
        pwm.duty_u16(-speed)
31
    else:
32
        in1.value(0)
33
        in2.value(0)
34
        pwm.duty_u16(0)
35

36

37
def drive(left, right):
38
    motor(b_in1, b_in2, b_pwm, left)
39
    motor(a_in1, a_in2, a_pwm, right)
40

41

42
def stop():
43
    drive(0, 0)
44

45

46
def read_distance():
47
    trigger.value(0)
48
    time.sleep_us(2)
49
    trigger.value(1)
50
    time.sleep_us(10)
51
    trigger.value(0)
52
    duration = time_pulse_us(echo, 1, TIMEOUT_US)
53
    if duration < 0:
54
        return -1
55
    return duration // 58
56

57

58
while True:
59
    cm = read_distance()
60
    if cm > 0 and cm < STOP_CM:
61
        stop()
62
    else:
63
        drive(SPEED, SPEED)
64
    time.sleep(0.05)

Task 2: Back Away and Turn

Stopping is not enough — it just sits there. Write back_away() that reverses briefly, then spins.
Put the reverse and turn durations in named constants so they are easy to change.
Set the robot down in a corner and let it work its way out.

1
from machine import Pin, PWM, time_pulse_us
2
import time
3

4
a_in1 = Pin(31, Pin.OUT)
5
a_in2 = Pin(32, Pin.OUT)
6
a_pwm = PWM(Pin(33))
7
a_pwm.freq(1000)
8

9
b_in1 = Pin(21, Pin.OUT)
10
b_in2 = Pin(35, Pin.OUT)
11
b_pwm = PWM(Pin(34))
12
b_pwm.freq(1000)
13

14
trigger = Pin(22, Pin.OUT)
15
echo = Pin(20, Pin.IN)
16

17
SPEED = 40000
18
STOP_CM = 20
19
BACK_TIME = 0.4
20
TURN_TIME = 0.5
21
TIMEOUT_US = 30000
22

23

24
def motor(in1, in2, pwm, speed):
25
    if speed > 0:
26
        in1.value(1)
27
        in2.value(0)
28
        pwm.duty_u16(speed)
29
    elif speed < 0:
30
        in1.value(0)
31
        in2.value(1)
32
        pwm.duty_u16(-speed)
33
    else:
34
        in1.value(0)
35
        in2.value(0)
36
        pwm.duty_u16(0)
37

38

39
def drive(left, right):
40
    motor(b_in1, b_in2, b_pwm, left)
41
    motor(a_in1, a_in2, a_pwm, right)
42

43

44
def stop():
45
    drive(0, 0)
46

47

48
def read_distance():
49
    trigger.value(0)
50
    time.sleep_us(2)
51
    trigger.value(1)
52
    time.sleep_us(10)
53
    trigger.value(0)
54
    duration = time_pulse_us(echo, 1, TIMEOUT_US)
55
    if duration < 0:
56
        return -1
57
    return duration // 58
58

59

60
def back_away():
61
    stop()
62
    time.sleep(0.2)
63
    drive(-SPEED, -SPEED)
64
    time.sleep(BACK_TIME)
65
    drive(SPEED, -SPEED)
66
    time.sleep(TURN_TIME)
67

68

69
while True:
70
    cm = read_distance()
71
    if cm > 0 and cm < STOP_CM:
72
        back_away()
73
    else:
74
        drive(SPEED, SPEED)
75
    time.sleep(0.05)

Task 3: Start on a Button Press

A robot that drives the instant you plug it in is impossible to work with.
Wait for a button press before entering the loop.

The wait is a loop whose body does nothing at all — the same pass trick you used to wait for a reaction in 2.7.

1
from machine import Pin, PWM, time_pulse_us
2
import time
3

4
a_in1 = Pin(31, Pin.OUT)
5
a_in2 = Pin(32, Pin.OUT)
6
a_pwm = PWM(Pin(33))
7
a_pwm.freq(1000)
8

9
b_in1 = Pin(21, Pin.OUT)
10
b_in2 = Pin(35, Pin.OUT)
11
b_pwm = PWM(Pin(34))
12
b_pwm.freq(1000)
13

14
trigger = Pin(22, Pin.OUT)
15
echo = Pin(20, Pin.IN)
16
button = Pin(28, Pin.IN, Pin.PULL_DOWN)
17

18
SPEED = 40000
19
STOP_CM = 20
20
BACK_TIME = 0.4
21
TURN_TIME = 0.5
22
TIMEOUT_US = 30000
23

24

25
def motor(in1, in2, pwm, speed):
26
    if speed > 0:
27
        in1.value(1)
28
        in2.value(0)
29
        pwm.duty_u16(speed)
30
    elif speed < 0:
31
        in1.value(0)
32
        in2.value(1)
33
        pwm.duty_u16(-speed)
34
    else:
35
        in1.value(0)
36
        in2.value(0)
37
        pwm.duty_u16(0)
38

39

40
def drive(left, right):
41
    motor(b_in1, b_in2, b_pwm, left)
42
    motor(a_in1, a_in2, a_pwm, right)
43

44

45
def stop():
46
    drive(0, 0)
47

48

49
def read_distance():
50
    trigger.value(0)
51
    time.sleep_us(2)
52
    trigger.value(1)
53
    time.sleep_us(10)
54
    trigger.value(0)
55
    duration = time_pulse_us(echo, 1, TIMEOUT_US)
56
    if duration < 0:
57
        return -1
58
    return duration // 58
59

60

61
def back_away():
62
    stop()
63
    time.sleep(0.2)
64
    drive(-SPEED, -SPEED)
65
    time.sleep(BACK_TIME)
66
    drive(SPEED, -SPEED)
67
    time.sleep(TURN_TIME)
68

69

70
print("Press the button to start.")
71
while button.value() == 0:
72
    pass
73

74
while True:
75
    cm = read_distance()
76
    if cm > 0 and cm < STOP_CM:
77
        back_away()
78
    else:
79
        drive(SPEED, SPEED)
80
    time.sleep(0.05)

Task 4: Say What It Is Thinking

Put the OLED back in and show the state and the current distance.
Translate -1 into something a human wants to read. Nobody should see the sentinel.
Now you can debug the robot while it drives, without a laptop.

1
from machine import Pin, PWM, time_pulse_us
2
import qwiic_large_oled
3
import time
4

5
a_in1 = Pin(31, Pin.OUT)
6
a_in2 = Pin(32, Pin.OUT)
7
a_pwm = PWM(Pin(33))
8
a_pwm.freq(1000)
9

10
b_in1 = Pin(21, Pin.OUT)
11
b_in2 = Pin(35, Pin.OUT)
12
b_pwm = PWM(Pin(34))
13
b_pwm.freq(1000)
14

15
trigger = Pin(22, Pin.OUT)
16
echo = Pin(20, Pin.IN)
17
button = Pin(28, Pin.IN, Pin.PULL_DOWN)
18

19
SPEED = 40000
20
STOP_CM = 20
21
BACK_TIME = 0.4
22
TURN_TIME = 0.5
23
TIMEOUT_US = 30000
24

25
oled = qwiic_large_oled.QwiicLargeOled()
26
oled.begin()
27

28

29
def motor(in1, in2, pwm, speed):
30
    if speed > 0:
31
        in1.value(1)
32
        in2.value(0)
33
        pwm.duty_u16(speed)
34
    elif speed < 0:
35
        in1.value(0)
36
        in2.value(1)
37
        pwm.duty_u16(-speed)
38
    else:
39
        in1.value(0)
40
        in2.value(0)
41
        pwm.duty_u16(0)
42

43

44
def drive(left, right):
45
    motor(b_in1, b_in2, b_pwm, left)
46
    motor(a_in1, a_in2, a_pwm, right)
47

48

49
def stop():
50
    drive(0, 0)
51

52

53
def read_distance():
54
    trigger.value(0)
55
    time.sleep_us(2)
56
    trigger.value(1)
57
    time.sleep_us(10)
58
    trigger.value(0)
59
    duration = time_pulse_us(echo, 1, TIMEOUT_US)
60
    if duration < 0:
61
        return -1
62
    return duration // 58
63

64

65
def back_away():
66
    stop()
67
    time.sleep(0.2)
68
    drive(-SPEED, -SPEED)
69
    time.sleep(BACK_TIME)
70
    drive(SPEED, -SPEED)
71
    time.sleep(TURN_TIME)
72

73

74
def show(oled, line1, line2):
75
    oled.clear(oled.PAGE)
76
    oled.print(line1)
77
    oled.print(line2)
78
    oled.display()
79

80

81
show(oled, "Rover ready", "press to start")
82
while button.value() == 0:
83
    pass
84

85
while True:
86
    cm = read_distance()
87
    if cm < 0:
88
        reading = "clear"
89
    else:
90
        reading = str(cm) + " cm"
91
    if cm > 0 and cm < STOP_CM:
92
        show(oled, "BLOCKED", reading)
93
        back_away()
94
    else:
95
        show(oled, "Driving", reading)
96
        drive(SPEED, SPEED)
97
    time.sleep(0.05)

[PHOTO PLACEHOLDER — Task 4: Rover Driving With Its Status on Screen]

Task 5: Tune It

No new code. Run the robot at an obstacle repeatedly and change one constant at a time.
Find a STOP_CM that stops without bumping, and a TURN_TIME that reliably faces somewhere new.
Record what you tried and what happened. Changing two things at once teaches you nothing.

Challenge (Optional): Look Both Ways

Instead of always turning the same direction, back up, turn a little each way, measure, and go whichever is clearer.
This is the difference between escaping a corner by luck and escaping it on purpose.

Checkpoint

The robot sits still until the button is pressed
It drives forward in open space and does not stop for nothing
It stops before touching an obstacle, then reverses and turns
Placed in a corner, it gets itself out within a few attempts
The screen shows what it is doing and never displays -1

Reflection

Answer the following questions before submitting your work.

Describe the sense–decide–act loop in your own words, naming which line of your program does each part. Why does it have to repeat rather than run once?
Leaving out cm > 0 makes the robot refuse to move in an empty room. Explain how a value you invented on purpose in 2.13 became a bug in 2.14, and what that suggests about using special values.
Nothing told you what STOP_CM or TURN_TIME should be. Describe how you found yours, and why changing one number at a time mattered.

Submit

Submit the required files to the appropriate dropbox.