Printable full course

Understand

Safety

• Use a USB cable that carries data, not a charge-only cable. A charge-only cable will power the board but Thonny will never see it.
• Hold the board by its edges. Dry hands, no metal on the table under the board.
• Nothing is wired in this mission, so there is nothing that can be wired backwards. Enjoy it while it lasts.

Parts

• 1 × Raspberry Pi Pico W board — From the Freenove Ultimate Starter Kit, or your own Pico W.
• 1 × USB data cable — Must carry data. Charge-only cables are the single most common cause of 'my board is invisible'.
• 1 × Computer with Thonny — Windows, macOS or Linux all work the same way for this course.

Electrical diagram

Connections

Wiring steps

1. Leave the breadboard in the box. This mission has no external wiring at all.
2. Check your USB cable is a data cable. If the board shows up as a drive in step 4 below, it is a data cable.

Build steps

1. Install Thonny from thonny.org and open it.
2. Download the current MicroPython firmware for the Raspberry Pi Pico W from the official Raspberry Pi documentation. Choose the file that says Pico W, not plain Pico.
3. Unplug the board. Find the small BOOTSEL button on top.
4. Hold BOOTSEL down, plug the USB cable into your computer while still holding, then let go. A drive named RPI-RP2 should appear.
5. Drag the .uf2 firmware file onto the RPI-RP2 drive. The drive disappears by itself after a few seconds. That means it worked.
6. In Thonny, open the interpreter selector at the bottom right (or Tools > Options > Interpreter) and choose MicroPython (Raspberry Pi Pico). Pick the serial port your board is on.
7. Look at the Shell panel. You want to see >>> waiting for you. Type 1 + 1 and press Enter to prove the board is answering.
8. Create a new file, paste the mission script, and save it to the Raspberry Pi Pico as mission-00.py.

Run steps

1. With mission-00.py open and saved on the board, press the green Run button in Thonny.
2. Read the Shell. Your greeting line appears first.
3. Watch the small LED on the board. It should turn on for half a second, off for half a second, over and over, and print a blink count each time.
4. Press the red stop button. Because of the finally block, the LED switches off instead of being frozen on.

mission-00.py

# mission-00.py - Meet the robot brain
# Junior Engineer Lab, Mission 00
# Raspberry Pi Pico W + MicroPython, run from Thonny.

from machine import Pin
import time

print("Hello! Junior Engineer Lab is online.")
print("This message was printed by the Pico W, not by your computer.")

# On a Pico W the onboard LED is reached by name.
# It is NOT GP25. On the older plain Pico it is GP25, which is why
# old tutorials fail here.
led = Pin("LED", Pin.OUT)

BLINKS = 20

try:
    for count in range(BLINKS):
        led.on()
        time.sleep(0.5)
        led.off()
        time.sleep(0.5)
        print("blink", count + 1, "of", BLINKS)
finally:
    # finally runs even if you press stop or an error happens.
    led.off()
    print("Finished. The LED has been switched off.")

The important lines

from machine import Pin

machine is the MicroPython module that talks to real hardware. Pin is the tool for controlling one pin.

led = Pin("LED", Pin.OUT)

Pico W only: the onboard LED has the name "LED". Pin.OUT means we want to push electricity out, not sense it.

time.sleep(0.5)

Wait half a second. Without a wait the blink would be far too fast for your eyes to see.

try: ... finally: led.off()

The finally block always runs, even when you stop the program early. It guarantees we leave the LED off.

Prediction

Question: You change both time.sleep(0.5) lines to time.sleep(0.05). What will the LED look like, and what will the Shell look like?

Expanded answer: The LED blinks ten times faster: 20 blinks finish in about 2 seconds instead of 20. At 0.05 s on and off your eye can still just about see the flicker, but it starts to look more like a shimmer than a blink. The Shell fills with blink lines very quickly, because the print happens once per loop no matter how fast the loop runs.

Extension challenge

Make the board blink a pattern that means something: your initials in Morse code, using 0.2 s for a dot and 0.6 s for a dash, with 0.2 s gaps inside a letter and 0.6 s between letters. Write the pattern down on paper first, then turn your paper plan into loops.

Troubleshooting

No RPI-RP2 drive appears when I hold BOOTSEL and plug in.

Almost always a charge-only USB cable, or BOOTSEL released too early. Try a different cable, and keep holding the button until after the plug is fully seated.

Thonny shows no serial port for the board.

Close any other program using the port, unplug and replug, then reselect the interpreter. On Linux your user may need to be in the dialout group.

The Shell prints my greeting but the LED stays dark.

You probably used Pin(25). On a Pico W you must use Pin("LED"). If you typed Pin("led") in lowercase it will also fail: the name is case sensitive.

I get OSError or the board hangs when I press Run.

Press the red stop button, then the Shell's restart. If that fails, unplug and replug the board and press Run again.

Real-hardware acceptance checklist

• ☐ The firmware drag-and-drop worked: the RPI-RP2 drive appeared and then disappeared on its own.
• ☐ Thonny's Shell shows the >>> prompt and answers when I type 1 + 1.
• ☐ My greeting lines printed in the Shell when I pressed Run.
• ☐ The real onboard LED on my board blinked about once per second.
• ☐ The LED was OFF after I pressed stop, not stuck on.
• ☐ My file is saved on the board as mission-00.py, not as main.py.

Notebook prompts

• Which firmware file did you download, and where did you get it from?
• What did the Shell print, word for word?
• What surprised you about the BOOTSEL trick?

Understand

Safety

• Build and change wiring with the USB cable unplugged. Plug in only when the circuit is finished and checked.
• Never connect a GPIO pin straight to ground with no resistor and no LED. That is a short circuit.
• Check the LED's long leg points away from ground before you power up.

Parts

• 1 × Pico W on the breadboard — Press it in firmly and squarely, pins straight down.
• 1 × Breadboard — The full-size board from the kit.
• 1 × Red LED — The long leg of an LED is the anode (the + side). The short leg, next to the flat notch on the plastic rim, is the cathode (the - side) and goes to ground.
• 1 × 1 kΩ resistor — Four-band colours: brown, black, red, gold.
• 2 × Jumper wires — One from GP16 into the board, one from a ground row back to physical pin 38.

Electrical diagram

Breadboard placement

Connections

Wiring steps

1. Unplug the USB cable before you touch anything.
2. Press the Pico W into the breadboard so that rows 8, 12 and 14 stay free. If that is impossible on your board, switch to the alternate rows 22, 26 and 28.
3. Run a jumper wire from physical pin 21 (GP16) to hole a8.
4. Push one leg of the 1 kΩ resistor into b8 and the other into b12.
5. Push the LED's long leg into e12 and its short, flat-side leg into e14.
6. Run a jumper wire from a14 to physical pin 38 (GND).
7. Trace the whole loop with your finger and say each hop out loud before you plug in.

Build steps

1. Plug the USB cable back in. Thonny should reconnect and show >>>.
2. Create a new file in Thonny and paste the mission script.
3. Save it to the Raspberry Pi Pico as mission-01.py.

Run steps

1. Press Run. The Shell prints that the LED is on.
2. Watch the real LED. It stays on steadily for ten seconds.
3. After ten seconds the script finishes and the finally block switches the LED off.
4. Press Run again and this time press stop after three seconds. The LED still goes off, because finally always runs.

mission-01.py

# mission-01.py - First external light
# Junior Engineer Lab, Mission 01
# GP16 (physical pin 21) -> 1 kohm resistor -> LED anode
# LED cathode (flat side) -> GND (physical pin 38)

from machine import Pin
import time

# Pin(16) means GPIO16. GPIO16 is physical pin 21 on the header.
# Pin(16) is NOT physical pin 16.
led = Pin(16, Pin.OUT)

ON_SECONDS = 10

try:
    led.on()
    print("LED on for", ON_SECONDS, "seconds")
    time.sleep(ON_SECONDS)
finally:
    led.off()
    print("LED off")

The important lines

led = Pin(16, Pin.OUT)

Claims GPIO16 as an output. Output means the pin decides the voltage: about 3.3 V when on, about 0 V when off.

led.on()

Sets GPIO16 high, so current can flow through the resistor and the LED.

time.sleep(ON_SECONDS)

Holds everything still for ten seconds so you can look at your work.

finally: led.off()

Guarantees the pin ends low. Pressing stop mid-run cannot leave the LED powered.

Prediction

Question: You turn the LED around so the long leg faces ground instead of the resistor. What happens when you press Run?

Expanded answer: Nothing lights up. An LED is a one-way valve for current, so backwards it simply blocks. The Shell still prints its messages happily, because the code has no idea what the circuit looks like. Nothing is damaged by this, because the 1 kΩ resistor is still limiting current. Turn the LED around and it works again. This is a useful habit: when the Shell talks but the hardware is silent, suspect the wiring, not the code.

Extension challenge

Change the script so the LED is on for 2 seconds, off for 1 second, three times, then off for good. Do it with a loop, not by copying and pasting the same lines three times, and keep the finally block.

Troubleshooting

LED never lights.

Check polarity first (long leg toward the resistor), then check you used physical pin 21 and not physical pin 16, then check both jumper wires are pushed fully in.

LED is on before I press Run.

Your jumper is probably in a 3.3 V pin instead of GP16. Unplug and recount the physical pins from the corner.

LED is extremely dim.

You may have fitted a much larger resistor, such as 10 kΩ. Check the colour bands: 1 kΩ is brown, black, red, gold.

It worked, then stopped when I nudged the board.

A leg has lifted out of its hole. Press all four points home. Loose legs are the most common intermittent fault on breadboards.

Real-hardware acceptance checklist

• ☐ My jumper really goes to physical pin 21, counted from the corner pin 1.
• ☐ A 1 kΩ resistor is fitted in the loop. The LED is never connected without it.
• ☐ The LED's long leg faces the resistor and the flat side faces ground.
• ☐ The ground wire goes to physical pin 38.
• ☐ The real LED on my breadboard lit up steadily for ten seconds.
• ☐ The LED was off after the script finished and also after pressing stop.

Notebook prompts

• Which rows did you use, the standard 8/12/14 or the alternate 22/26/28? Why?
• Draw your loop in four hops and label each one.
• Did anything go wrong the first time? What was it?

Understand

Safety

• Still unplug before touching the wiring, even though you are not changing it.
• Fast flashing light can bother some people. Keep it on the table, not pointed at a face.

Parts

• 1 × Mission 01 circuit, unchanged — GP16, 1 kΩ resistor, red LED, ground on physical 38.

Electrical diagram

Connections

Wiring steps

1. Leave the circuit exactly as it is.
2. Give every leg a gentle press to be sure nothing worked loose since last time.

Build steps

1. Open a new file in Thonny, paste the script, and save it to the board as mission-02.py.
2. Before you run it, work out on paper how long one complete group takes.

Run steps

1. Press Run and count along: flash, flash, flash, dark pause.
2. Check the LED is genuinely dark through the whole 1 second pause.
3. Watch the Shell count the groups, and compare the real rhythm with the timing you predicted.
4. Press stop. The finally block leaves the LED off.

mission-02.py

# mission-02.py - Rescue beacon
# Junior Engineer Lab, Mission 02
# Same wiring as Mission 01:
# GP16 (physical 21) -> 1 kohm -> LED -> GND (physical 38)

from machine import Pin
import time

led = Pin(16, Pin.OUT)

GROUPS = 10
FLASHES_PER_GROUP = 3
FLASH_ON = 0.15
FLASH_OFF = 0.15
LONG_PAUSE = 1.0

try:
    for group in range(GROUPS):
        # Inner loop: three quick flashes.
        for flash in range(FLASHES_PER_GROUP):
            led.on()
            time.sleep(FLASH_ON)
            led.off()
            time.sleep(FLASH_OFF)

        # The long pause must be completely dark.
        led.off()
        time.sleep(LONG_PAUSE)
        print("group", group + 1, "of", GROUPS, "finished")
finally:
    led.off()
    print("Beacon stopped. LED off.")

The important lines

for group in range(GROUPS):

The outer loop. One trip through it produces one complete group plus the long pause.

for flash in range(FLASHES_PER_GROUP):

The inner loop. It runs fully, three times, every single time the outer loop steps once.

led.off() time.sleep(LONG_PAUSE)

Switching off before the long sleep guarantees a dark pause. Order matters: sleeping first and switching off after would leave the LED lit for a second.

FLASH_ON = 0.15

Named constants at the top mean you can retune the whole pattern in one place instead of hunting through the loops.

Prediction

Question: What would happen if you moved the led.off() line to AFTER time.sleep(LONG_PAUSE)?

Expanded answer: The long pause would be lit instead of dark. The inner loop already left the LED off, but it would be switched on... actually no: it would stay off, because nothing turned it on. The real bug shows up if you write led.on() by accident, or if you remove the inner loop's final led.off(). The important lesson is that with hardware, the ORDER of switch and wait decides what your eyes see. A wait does not pause the electricity; the pin keeps doing whatever it was last told to do for the whole wait.

Extension challenge

Turn it into real Morse code SOS: three short flashes, three long flashes, three short flashes, then a long dark gap. Use 0.2 s for short, 0.6 s for long, 0.2 s between flashes and 1.4 s between whole SOS messages. Use a list of durations and one loop rather than 9 copied blocks.

Troubleshooting

Flashes look like one continuous blink.

Check you kept both 0.15 s sleeps. With no off-time the LED never visibly goes dark.

The pause is lit, not dark.

A led.on() has crept below the inner loop, or the inner loop's led.off() was deleted.

Shell prints groups but the LED does nothing.

Wiring problem, not a code problem. Re-check polarity and physical pin 21.

Groups come faster than I expected.

Re-do the timing sum: 3 x (0.15 + 0.15) + 1.0 = 1.9 s per group.

Real-hardware acceptance checklist

• ☐ My real LED flashed in clear groups of exactly three.
• ☐ The LED was completely dark for the whole long pause.
• ☐ The group number printed in the Shell after each group.
• ☐ I measured or counted one group and it was close to 1.9 seconds.
• ☐ The LED was off after the script ended and after pressing stop.

Notebook prompts

• What timing did you predict for one group, and what did you observe?
• Explain the inner and outer loop in your own words.
• What pattern would you use for your own signal, and why?

Understand

Safety

• Unplug the USB cable while you add the two extra LEDs.
• Count the physical pins twice. GP18 is physical 24, and physical 23 next to it is ground.
• Three LEDs means three chances to fit an LED backwards. Check all three long legs before powering up.

Parts

• 1 × Red LED — On GP16, as in Mission 01.
• 1 × Yellow LED — On GP17.
• 1 × Green LED — On GP18.
• 3 × 1 kΩ resistors — One per LED. Never share a single resistor between LEDs.
• 4 × Jumper wires — Three signal wires plus one ground wire.

Electrical diagram

Connections

Wiring steps

1. Unplug the USB cable.
2. Keep your red LED branch from Mission 01 in place.
3. Pick a free row for a shared ground node and run one jumper from it to physical pin 38.
4. Move the red LED's cathode row so it connects to the shared ground node instead of its own private ground wire.
5. Build the yellow branch in fresh rows: jumper from physical 22 (GP17), then a 1 kΩ resistor, then the yellow LED's long leg, with its flat side going to the shared ground node.
6. Build the green branch the same way from physical 24 (GP18).
7. Point at each long leg in turn and confirm it faces its resistor, not ground.
8. Count the physical pins from the corner once more: 21, 22, 24.

Build steps

1. Plug the USB cable back in and let Thonny reconnect.
2. Paste the script into a new file and save it to the board as mission-03.py.
3. Before running, predict the order of lights out loud.

Run steps

1. Press Run and watch for red 3 s, green 3 s, yellow 1 s, repeating.
2. Check carefully that only one LED is ever lit at a time.
3. Read the Shell: it names the light that is currently on.
4. Press stop and confirm all three LEDs go dark together.

mission-03.py

# mission-03.py - Traffic lights
# Junior Engineer Lab, Mission 03
# GP16 (physical 21) -> 1 kohm -> RED LED
# GP17 (physical 22) -> 1 kohm -> YELLOW LED
# GP18 (physical 24) -> 1 kohm -> GREEN LED
# All three LED cathodes -> shared ground node -> GND (physical 38)

from machine import Pin
import time

red = Pin(16, Pin.OUT)
yellow = Pin(17, Pin.OUT)
green = Pin(18, Pin.OUT)

lights = (red, yellow, green)

CYCLES = 5
RED_SECONDS = 3
GREEN_SECONDS = 3
YELLOW_SECONDS = 1


def show_only(chosen, name="all off"):
    """Switch every light off, then switch on just the chosen one."""
    for light in lights:
        light.off()
    if chosen is not None:
        chosen.on()
    print("now showing:", name)


try:
    for cycle in range(CYCLES):
        print("cycle", cycle + 1, "of", CYCLES)

        show_only(red, "red")
        time.sleep(RED_SECONDS)

        show_only(green, "green")
        time.sleep(GREEN_SECONDS)

        show_only(yellow, "yellow")
        time.sleep(YELLOW_SECONDS)
finally:
    show_only(None)
    print("Sequence finished. All lights off.")

The important lines

lights = (red, yellow, green)

A tuple holding all three pins so the function can loop over every light without naming them one by one.

for light in lights: light.off()

The safety rule: everything off first. This is what stops two lights being lit at the same time.

if chosen is not None:

Lets us call show_only(None) to mean 'all off', which is exactly what the finally block needs.

show_only(red, 'red')

One short line replaces four on/off lines, and it can never forget the all-off step.

Prediction

Question: You delete the two lines that switch every light off at the start of show_only. What will you see after a full cycle?

Expanded answer: Lights pile up. Red comes on and stays on. Then green joins it, so red and green are both lit. Then yellow joins, and all three are lit. From then on all three stay lit forever and the sequence becomes invisible. This is why the all-off step lives inside the function: it is impossible to forget it at one of the call sites.

Extension challenge

Add a pedestrian crossing. Use a fourth LED on a free GPIO pin with its own 1 kΩ resistor. During the red car phase, flash the pedestrian LED on and off every 0.25 s to mean 'walk now', and keep it off the rest of the time. Write the pedestrian flashing as its own function.

Troubleshooting

Two lights are on together.

The all-off loop is missing or the sequence switches lights on directly instead of through show_only.

Green never lights.

You almost certainly wired GP18 to physical 23 instead of physical 24. Physical 23 is a ground pin.

One LED is much dimmer than the others.

Different resistor value in that branch, or two LEDs sharing one resistor. Each LED needs its own 1 kΩ.

All three LEDs are dark but the Shell is talking.

The shared ground node is not actually reaching physical pin 38. Check that jumper.

Real-hardware acceptance checklist

• ☐ Red is on GP16 / physical 21, yellow on GP17 / physical 22, green on GP18 / physical 24.
• ☐ Each LED has its own 1 kΩ resistor. No resistor is shared.
• ☐ All three cathodes meet at one shared ground node that reaches physical pin 38.
• ☐ I watched a full cycle on real hardware: red 3 s, green 3 s, yellow 1 s.
• ☐ Only ever one LED was lit at a time.
• ☐ All three LEDs were off after the script ended and after pressing stop.

Notebook prompts

• Why does each LED need its own resistor? Explain it to someone at home.
• Write the physical pin number next to each GPIO number you used.
• What did show_only save you from?

Understand

Safety

• Unplug the USB cable before you add the button.
• Any continuity check with a multimeter is done with the board unplugged, by an adult.
• Never wire the button between 3.3 V and ground with nothing else. That is a short circuit you can create by accident when hunting for legs.

Parts

• 1 × Mission 01 LED branch — GP16, 1 kΩ, red LED, ground.
• 1 × Four-leg tactile pushbutton — Two internally joined pairs. Use one leg from each of two different pairs.
• 2 × Jumper wires — One from GP15 to contact A, one from contact B to ground.

Electrical diagram

Connections

Wiring steps

1. Unplug the USB cable.
2. Keep the GP16 LED branch exactly as it is, with its cathode going to a shared ground node that reaches physical pin 38.
3. Press the pushbutton firmly across the trench so that its two pairs land on opposite sides. Straddling the trench is the standard way to keep the pairs separated.
4. Identify a leg from each of two different internal pairs, using the Freenove drawing or an adult's unpowered continuity check.
5. Run a jumper from physical pin 20 (GP15) to the row holding contact A.
6. Run a jumper from the row holding contact B to the shared ground node.
7. Double-check that contacts A and B are not two legs from the same joined pair.

Build steps

1. Plug the USB cable back in.
2. Paste the script into a new file and save it to the board as mission-04.py.
3. Decide, before you run it, whether released should read 0 or 1.

Run steps

1. Press Run. The Shell starts reporting the button reading whenever it changes.
2. Do not touch the button: the Shell should settle on reading 1 and the LED should be off.
3. Press and hold. The reading becomes 0 and the LED lights for as long as you hold.
4. Release. Reading goes back to 1 and the LED goes out.
5. Press stop. The finally block leaves the LED off.

mission-04.py

# mission-04.py - Button light
# Junior Engineer Lab, Mission 04
# GP16 (physical 21) -> 1 kohm -> LED -> ground node -> GND (physical 38)
# GP15 (physical 20) -> button contact A
# button contact B -> ground node
# Contacts A and B must be legs from two DIFFERENT internal pairs.

from machine import Pin
import time

led = Pin(16, Pin.OUT)

# PULL_UP holds the input at 1 when nothing is connecting it to ground.
# Released reads 1. Pressed reads 0.
button = Pin(15, Pin.IN, Pin.PULL_UP)

last_reading = None

try:
    while True:
        reading = button.value()

        # Released: 1 - 1 = 0, LED off.
        # Pressed:  1 - 0 = 1, LED on.
        led.value(1 - reading)

        if reading != last_reading:
            if reading == 0:
                print("reading 0 -> button pressed -> LED on")
            else:
                print("reading 1 -> button released -> LED off")
            last_reading = reading

        time.sleep(0.01)
except KeyboardInterrupt:
    pass
finally:
    led.off()
    print("Stopped. LED off.")

The important lines

button = Pin(15, Pin.IN, Pin.PULL_UP)

Pin.IN means measure, do not drive. Pin.PULL_UP switches on the resistor inside the chip so a released button reads a steady 1 instead of random noise.

led.value(1 - reading)

Flips the inverted button logic into LED logic. Pressed (0) becomes 1 (on); released (1) becomes 0 (off).

if reading != last_reading:

Only print when something actually changes. Without this the Shell would print a hundred identical lines every second.

except KeyboardInterrupt: pass

Stopping the program is normal here, not an error, so we swallow it quietly and let finally clean up.

Prediction

Question: Your LED is lit the moment you press Run and stays lit no matter what you do with the button. What is wrong?

Expanded answer: You picked two legs from the SAME internal pair, so your 'button' is actually a permanent wire from GP15 to ground. The input therefore reads 0 forever and 1 - 0 = 1 keeps the LED on. Move one jumper to a leg from the other pair. The usual trick is to straddle the button across the trench so the pairs sit on opposite sides, and to confirm the pairing from the manufacturer's drawing rather than guessing.

Extension challenge

Make the button a toggle instead of a hold switch: one press turns the LED on and leaves it on, the next press turns it off. You will need a variable to remember the state, and you will need to wait for the button to be released before you accept another press, otherwise one press flips the state dozens of times. Keep that solution: Mission 11 needs exactly this skill.

Troubleshooting

LED always on.

Both button jumpers are on the same internally joined pair. Use one leg from each of two different pairs.

LED never responds and reading never changes from 1.

Contact B is not reaching ground, or a button leg is not pushed fully into its hole.

Reading flickers randomly between 0 and 1 when untouched.

PULL_UP is missing from the Pin() call, so the input is floating.

LED is inverted: on when released, off when pressed.

You wrote led.value(reading) instead of led.value(1 - reading).

Real-hardware acceptance checklist

• ☐ The button is wired between GP15 / physical 20 and the ground node.
• ☐ I confirmed contacts A and B are from two different internal pairs, using the drawing or an adult's unpowered continuity check.
• ☐ With the button untouched, the Shell showed a steady reading of 1.
• ☐ Pressing the real button lit the real LED, and releasing it switched the LED off.
• ☐ The LED was off after I pressed stop.

Notebook prompts

• Why does a released button read 1 instead of 0?
• How did you work out which button legs to use?
• Explain 1 - reading in your own words.

Understand

Safety

• No wiring changes, so nothing new to get wrong. Still check your legs are seated before plugging in.
• Do not hammer the button. It is a small mechanical part and you want it to survive Mission 11.

Parts

• 1 × Mission 04 circuit, unchanged — GP16 LED with 1 kΩ, GP15 button with internal pull-up, shared ground on physical 38.

Electrical diagram

Connections

Wiring steps

1. Leave the Mission 04 wiring untouched.
2. Press each leg gently to check nothing has lifted.

Build steps

1. Paste the script into a new file and save it to the board as mission-05.py.
2. Read the three small helper functions before you run anything, and work out what each one waits for.

Run steps

1. Press Run. The Shell asks you to press to start.
2. Press and release the button. Now wait, hands still.
3. The moment the LED lights, press as fast as you can. Your time in milliseconds appears in the Shell.
4. Deliberately cheat: start a round and press early. The Shell prints Too soon! and the round is abandoned.
5. Play five fair rounds, write your times in the notebook section, then press stop.

mission-05.py

# mission-05.py - Reaction game
# Junior Engineer Lab, Mission 05
# Same wiring as Mission 04.
# GP16 (physical 21) -> 1 kohm -> LED -> ground node -> GND (physical 38)
# GP15 (physical 20) -> button contact A, contact B -> ground node

from machine import Pin
import time
import random

led = Pin(16, Pin.OUT)
button = Pin(15, Pin.IN, Pin.PULL_UP)

MIN_WAIT_MS = 1500
MAX_WAIT_MS = 4000
DEBOUNCE_MS = 30


def wait_for_press():
    """Block until the button goes from released (1) to pressed (0)."""
    while button.value() == 1:
        time.sleep_ms(1)


def wait_for_release():
    """Block until the button is released, then debounce."""
    while button.value() == 0:
        time.sleep_ms(1)
    time.sleep_ms(DEBOUNCE_MS)


try:
    while True:
        led.off()
        print("")
        print("Press the button to start a round.")
        wait_for_press()
        wait_for_release()

        wait_ms = random.randint(MIN_WAIT_MS, MAX_WAIT_MS)
        print("Wait for the light...")

        start = time.ticks_ms()
        false_start = False

        # Watchful wait: we must keep checking the button, so a sleep is no good.
        while time.ticks_diff(time.ticks_ms(), start) < wait_ms:
            if button.value() == 0:
                false_start = True
                break
            time.sleep_ms(1)

        if false_start:
            print("Too soon! That is a false start.")
            wait_for_release()
            continue

        led.on()
        light_time = time.ticks_ms()

        wait_for_press()
        # ticks_diff, never plain subtraction: the tick counter can wrap around.
        reaction_ms = time.ticks_diff(time.ticks_ms(), light_time)

        led.off()
        print("Reaction time:", reaction_ms, "ms")
        wait_for_release()
except KeyboardInterrupt:
    pass
finally:
    led.off()
    print("Game over. LED off.")

The important lines

reaction_ms = time.ticks_diff(time.ticks_ms(), light_time)

The correct way to measure elapsed time. ticks_diff handles the counter wrapping around; plain subtraction does not.

while time.ticks_diff(time.ticks_ms(), start) < wait_ms:

A watchful wait. Because we loop instead of sleeping, we can spot an early press and call it a false start.

wait_ms = random.randint(MIN_WAIT_MS, MAX_WAIT_MS)

A fresh random delay each round, so the game cannot be learned by rhythm.

while button.value() == 0: time.sleep_ms(1) time.sleep_ms(DEBOUNCE_MS)

Wait for release, then 30 ms of debounce. Without this, the contact bouncing would instantly start the next round.

Prediction

Question: You replace the watchful wait loop with a single time.sleep_ms(wait_ms). What breaks?

Expanded answer: False starts stop being detected. While the program is sleeping it cannot look at the button, so pressing early is simply ignored. Worse, an early press can leave the contact state such that the next wait_for_press returns immediately, giving an impossibly fast score like 2 ms. You would be able to cheat by pressing early every round. The watchful loop exists specifically so the program is never blind to its input.

Extension challenge

Keep score across rounds. Store each valid reaction time in a list, and after every round print the best time and the average of all valid rounds so far. Remember that false starts should not be added to the list. Round the average to a whole number of milliseconds before printing it.

Troubleshooting

Every round reports about 1 or 2 ms.

A stray press is being counted. Make sure wait_for_release is called after the false start and after each measured press.

Rounds start by themselves.

Debounce missing or too short. Keep the 30 ms wait after the button is released.

I get negative or absurdly large times.

Plain subtraction of ticks has crept in somewhere. Use ticks_diff everywhere.

Too soon! never appears, even when I cheat.

The wait is a sleep instead of a watchful loop, so the button is not being checked during the wait.

Real-hardware acceptance checklist

• ☐ A real round worked end to end on hardware: press, wait, light, press, time printed.
• ☐ I deliberately pressed early and the Shell printed Too soon!.
• ☐ Holding the button down did not start round after round by itself.
• ☐ My times look human: roughly 150 to 400 ms, not 2 ms.
• ☐ The LED was off after the game stopped.
• ☐ I recorded at least three of my real times in the notebook.

Notebook prompts

• List your reaction times. What was your best, and your typical?
• Why must ticks_diff be used instead of subtracting?
• How does the program catch a false start?

Understand

Safety

• Wiring is unchanged from Mission 01, so unplug only if you need to reseat something.
• Keep the 1 kΩ resistor. PWM does not remove the need for current limiting.

Parts

• 1 × Mission 01 circuit, unchanged — GP16 -> 1 kΩ -> red LED -> GND physical 38.

Electrical diagram

Connections

Wiring steps

1. Leave the Mission 01 circuit in place.
2. Confirm the 1 kΩ resistor is still fitted.

Build steps

1. Paste the script into a new file and save it to the board as mission-06.py.
2. Predict how long one complete breath will take before you run it.

Run steps

1. Press Run and watch the LED swell and fade, five times.
2. Compare the real fade speed with your prediction of about 1.3 seconds per breath.
3. Change STEP to 8192 and run again: the fade becomes visibly steppy. Change it back to 1024.
4. Press stop and confirm the LED goes fully dark, not dimly glowing.

mission-06.py

# mission-06.py - Breathing LED
# Junior Engineer Lab, Mission 06
# Same wiring as Mission 01:
# GP16 (physical 21) -> 1 kohm -> LED -> GND (physical 38)

from machine import Pin, PWM
import time

led = PWM(Pin(16))
led.freq(1000)        # 1000 switch cycles per second
led.duty_u16(0)       # start fully off

STEP = 1024
STEP_DELAY_MS = 10
BREATHS = 5

try:
    for breath in range(BREATHS):
        # Fade up.
        for duty in range(0, 65536, STEP):
            led.duty_u16(min(duty, 65535))
            time.sleep_ms(STEP_DELAY_MS)

        # Fade down.
        for duty in range(65535, -1, -STEP):
            led.duty_u16(max(duty, 0))
            time.sleep_ms(STEP_DELAY_MS)

        print("breath", breath + 1, "of", BREATHS)
finally:
    led.duty_u16(0)
    led.deinit()
    print("PWM released. LED off.")

The important lines

led = PWM(Pin(16)) led.freq(1000)

Turns GPIO16 into a fast-switching output and sets 1000 complete on/off cycles per second: too fast for your eye to see flicker.

led.duty_u16(duty)

Sets the fraction of each cycle that the pin is high, from 0 (never) to 65535 (always). This controls apparent brightness.

for duty in range(0, 65536, STEP):

64 steps of 1024 to climb from off to full. Bigger steps look jumpy; smaller steps just take longer.

led.duty_u16(0) led.deinit()

Cleanup: switch the output fully off, then release the PWM hardware so the next script can claim the pin cleanly.

Prediction

Question: At duty_u16(32768), what voltage would you measure at GP16 with a voltmeter, and why?

Expanded answer: A simple voltmeter would show roughly 1.65 V, about half of 3.3 V. But that reading is an average: the pin is genuinely at 3.3 V for half of every millisecond and 0 V for the other half. It is never actually sitting at 1.65 V. A meter is just too slow to follow the switching, so it reports the average, exactly like your eye reports average brightness. On an oscilloscope you would see a clean square wave between 0 V and 3.3 V with equal high and low times.

Extension challenge

Make a heartbeat instead of a breath: a quick bright pulse, a short dim gap, a second quick pulse, then a longer dark rest. Use your own fade speeds for each phase, and keep the full cleanup in finally.

Troubleshooting

LED flickers visibly instead of fading smoothly.

Your frequency is too low. Check led.freq(1000). Below about 100 Hz the flicker becomes visible.

The fade is steppy.

STEP is too large. 1024 gives 64 smooth steps.

LED stays dimly lit after the script ends.

The finally block is missing duty_u16(0) or deinit().

ValueError about the duty value.

A duty above 65535 was passed. The min() and max() guards in the script prevent this.

Real-hardware acceptance checklist

• ☐ My real LED faded smoothly up and down without visible flicker.
• ☐ One complete breath took roughly 1.3 seconds, close to my prediction.
• ☐ I tried a larger STEP and saw the fade become steppy, then put it back.
• ☐ The LED was completely dark after the script finished, with no faint glow.
• ☐ I can explain that the pin voltage is still only 0 V or 3.3 V.

Notebook prompts

• In your own words, what is a duty cycle?
• Why does the LED look dim if the pin is never at a low voltage?
• What happened when you changed STEP?

Understand

Safety

• Unplug before wiring the potentiometer.
• Take 3.3 V from 3V3 OUT at physical pin 36. Never use VBUS or VSYS, which carry 5 V.
• Make sure the two outer pot legs are not both in the same breadboard row, which would short 3.3 V straight to ground.

Parts

• 1 × Mission 06 LED branch — GP16 PWM output with 1 kΩ resistor and red LED. Keep it.
• 1 × 10 kΩ potentiometer — Three legs: two outer ends and a centre wiper.
• 3 × Jumper wires — 3.3 V in, wiper out to GP26, ground out.

Electrical diagram

Connections

Wiring steps

1. Unplug the USB cable.
2. Keep the GP16 LED branch with its 1 kΩ resistor exactly as it is.
3. Press the potentiometer into three separate rows so each leg has its own row.
4. Jumper from physical pin 36 (3V3 OUT) to the row holding one outer leg.
5. Jumper from the row holding the other outer leg to the shared ground node.
6. Jumper from the row holding the centre wiper to physical pin 31 (GP26).
7. Check that the two outer legs are in different rows. If they share a row you have shorted 3.3 V to ground.

Build steps

1. Plug the USB cable back in.
2. Paste the script into a new file and save it to the board as mission-07.py.
3. Turn the knob fully one way before you run it, so you know where you are starting.

Run steps

1. Press Run. Readings start scrolling in the Shell every 100 ms.
2. Turn the knob slowly from one end to the other and watch the numbers sweep toward 0 and toward 65535.
3. Watch the real LED brightness follow your hand.
4. Hold the knob still and notice the last digits still jitter. That is normal analog noise.
5. Press stop and confirm the LED goes fully dark.

mission-07.py

# mission-07.py - Brightness knob
# Junior Engineer Lab, Mission 07
# 3V3 OUT (physical 36) -> pot outer leg A
# pot centre wiper      -> GP26 / ADC0 (physical 31)
# pot outer leg B       -> ground node -> GND (physical 38)
# GP16 (physical 21) -> 1 kohm -> LED -> ground node

from machine import Pin, PWM, ADC
import time

led = PWM(Pin(16))
led.freq(1000)
led.duty_u16(0)

# Only GP26, GP27 and GP28 can be analog inputs on a Pico W.
knob = ADC(Pin(26))

PRINT_DELAY_MS = 100

try:
    while True:
        # read_u16 reports 0..65535, but the chip's converter is really
        # 12-bit, so the lowest digits will always wobble a little.
        reading = knob.read_u16()

        # Happy coincidence: read_u16 and duty_u16 use the same range.
        led.duty_u16(reading)

        volts = reading * 3.3 / 65535
        print("knob reading:", reading, " estimated volts:", round(volts, 2))

        time.sleep_ms(PRINT_DELAY_MS)
except KeyboardInterrupt:
    pass
finally:
    led.duty_u16(0)
    led.deinit()
    print("Stopped. PWM released, LED off.")

The important lines

knob = ADC(Pin(26))

Claims GPIO26 as an analog input. Only GP26, GP27 and GP28 can do this on a Pico W.

reading = knob.read_u16()

Measures the wiper voltage and reports 0 for about 0 V up to 65535 for about 3.3 V. Reported range is 16-bit; underlying precision is 12-bit.

led.duty_u16(reading)

The reading range and the duty range match exactly, so the knob can drive brightness with no conversion.

volts = reading * 3.3 / 65535

Turns the raw number back into an estimated voltage so the Shell output means something physical.

Prediction

Question: You accidentally put both outer pot legs into the same breadboard row. What happens, and why is it bad?

Expanded answer: You have connected 3.3 V directly to ground through almost no resistance: a short circuit. The pot's resistive strip is bypassed, so a large current flows through the jumper wires instead of being limited. The Pico's regulator may protect itself by shutting down, the board may disconnect from Thonny, and the wires can get warm. The reading would also stop responding to the knob, because the wiper now sits at one fixed voltage. Always give each pot leg its own row.

Extension challenge

Smooth the noise. Take 10 readings in a row with a 2 ms gap, add them up, divide by 10, and use that average for the brightness and the printout. Compare how much the last digits jitter before and after averaging. This technique is called a moving average and is used constantly in real sensor code.

Troubleshooting

Reading is stuck near 0 or near 65535.

One outer leg is not connected, or the wiper jumper is in the wrong row. Give all three legs their own row.

Reading jumps all over with the knob untouched.

The wiper is not reaching GP26 at all, so the input is floating. Check physical pin 31.

LED brightness does not change.

You may still be running Mission 06's script, or the LED is no longer on a PWM pin. Check you saved and ran mission-07.py.

Board disconnects from Thonny when I plug in.

Unplug immediately. Look for a short: most likely both outer pot legs in one row, or a wire into VBUS instead of 3V3 OUT.

Real-hardware acceptance checklist

• ☐ 3.3 V comes from physical pin 36 (3V3 OUT), not from VBUS or VSYS.
• ☐ The wiper goes to GP26 at physical pin 31, and each pot leg has its own row.
• ☐ Turning the real knob swept the printed reading between roughly 0 and 65535.
• ☐ The real LED brightness followed the knob smoothly.
• ☐ I noticed the small jitter in the readings and understand why it happens.
• ☐ The LED was off after I pressed stop.

Notebook prompts

• Write down your lowest and highest reading. Did you reach 0 and 65535 exactly?
• Explain a voltage divider in your own words.
• Why is the real precision 12-bit even though the number goes to 65535?

Understand

Safety

• Unplug before removing the potentiometer and fitting the LDR.
• Use the bare two-leg LDR from the kit, not a sensor module with extra pins.
• Keep 3.3 V from physical pin 36. Do not use 5 V anywhere near a GPIO pin.

Parts

• 1 × Mission 01 LED branch — GP16 -> 1 kΩ -> red LED -> ground. Keep it, as a plain digital output this time.
• 1 × Light-dependent resistor (LDR) — Bare two-leg component. No polarity.
• 1 × 10 kΩ resistor — The fixed half of the divider. Not the 1 kΩ: that one is for the LED.
• 3 × Jumper wires — 3.3 V in, junction out to GP26, ground out.

Electrical diagram

Connections

Wiring steps

1. Unplug the USB cable and remove the potentiometer completely.
2. Keep the GP16 LED branch with its 1 kΩ resistor.
3. Choose a free row to be the JUNCTION row.
4. Jumper from physical pin 36 (3V3 OUT) to a row, and put one LDR leg in that row.
5. Put the LDR's other leg into the JUNCTION row.
6. Put one leg of the 10 kΩ resistor into the JUNCTION row and its other leg into the shared ground node.
7. Jumper from the JUNCTION row to physical pin 31 (GP26).
8. Confirm three things share the JUNCTION row: an LDR leg, a 10 kΩ leg and the GP26 jumper.

Build steps

1. Plug the USB cable back in.
2. Paste the script into a new file and save it to the board as mission-08.py.
3. Run it once with the default LOW = 20000 and HIGH = 40000 just to see live readings.
4. Cover the LDR and write down the dark reading D. Shine a torch and write down the bright reading B.
5. Edit LOW and HIGH so that D < LOW < HIGH < B, then save and run again. If your assert fails, your numbers are in the wrong order.

Run steps

1. Press Run and watch the readings and the lamp state in the Shell.
2. Cover the LDR with your hand. The reading drops below LOW and the real LED switches on.
3. Uncover it fully. The reading climbs above HIGH and the LED switches off.
4. Now hold your hand half over the LDR so the reading sits between LOW and HIGH. The lamp must hold steady, not flicker. That is hysteresis working.
5. Press stop and confirm the LED is off.

mission-08.py

# mission-08.py - Automatic nightlight
# Junior Engineer Lab, Mission 08
# 3V3 OUT (physical 36) -> LDR -> JUNCTION
# JUNCTION -> GP26 / ADC0 (physical 31)
# JUNCTION -> 10 kohm -> ground node -> GND (physical 38)
# GP16 (physical 21) -> 1 kohm -> LED -> ground node

from machine import Pin, ADC
import time

# Calibrate these for YOUR room.
# Cover the sensor to find the dark reading D.
# Shine a light on it to find the bright reading B.
# Then choose D < LOW < HIGH < B.
LOW = 20000
HIGH = 40000

assert 0 <= LOW < HIGH <= 65535, "Thresholds must be in range and LOW must be below HIGH"

led = Pin(16, Pin.OUT)
sensor = ADC(Pin(26))

SAMPLE_DELAY_MS = 200

# The lamp remembers what it was doing. This is what makes
# the in-between band possible.
lit = False

try:
    while True:
        reading = sensor.read_u16()

        if reading < LOW:
            lit = True          # definitely dark
        elif reading > HIGH:
            lit = False         # definitely bright
        # else: inside the dead band, so leave 'lit' exactly as it was.

        led.value(1 if lit else 0)
        print("light reading:", reading, " lamp:", "ON" if lit else "off")

        time.sleep_ms(SAMPLE_DELAY_MS)
except KeyboardInterrupt:
    pass
finally:
    led.off()
    print("Stopped. Lamp off.")

The important lines

assert 0 <= LOW < HIGH <= 65535

Stops the program immediately with a clear message if your calibration numbers are impossible or the wrong way round.

lit = False

The memory of the lamp's current state. Without this variable the dead band could not keep its value.

if reading < LOW: lit = True elif reading > HIGH: lit = False

Two thresholds, not one. The missing else is deliberate: in between, nothing changes, so the lamp holds steady.

led.value(1 if lit else 0)

Applies the remembered state to the real pin on every pass through the loop.

Prediction

Question: Suppose you used a single threshold of 30000 instead: lamp on below it, off above it. You hold your hand so the reading hovers around 29900 to 30100. What happens?

Expanded answer: The lamp flickers rapidly on and off. Analog readings always carry a little noise, so a reading sitting right at the line crosses it many times a second, and the lamp follows every crossing. With hysteresis the reading has to travel all the way down past LOW to switch on, and all the way up past HIGH to switch off, so noise in the middle changes nothing. Real thermostats and fridges use exactly this trick to stop their motors switching on and off constantly.

Extension challenge

Add a dusk delay so a passing shadow does not trigger the lamp. Only switch the lamp on after the reading has been continuously below LOW for 3 whole seconds, and only switch it off after it has been continuously above HIGH for 3 seconds. Use ticks_ms and ticks_diff to time it, and reset the timer whenever the reading leaves the band you are timing.

Troubleshooting

AssertionError as soon as I run it.

Your LOW is not below your HIGH, or one of them is outside 0 to 65535. Recheck your calibration numbers.

Lamp is on all the time.

Your readings never climb above HIGH. Lower HIGH, or check the 3.3 V jumper is on physical pin 36.

Lamp is off all the time.

Your readings never drop below LOW. Raise LOW, or cover the LDR more completely.

Readings barely change when I cover the LDR.

The JUNCTION row probably is not shared by all three connections. Check the LDR leg, the 10 kΩ leg and the GP26 jumper are all in the same row.

Bright light makes the reading go DOWN, not up.

Your LDR and 10 kΩ are swapped. Either swap them back or simply calibrate for the behaviour you measured, keeping LOW below HIGH.

Real-hardware acceptance checklist

• ☐ The JUNCTION row genuinely shares the LDR leg, the 10 kΩ leg and the GP26 jumper.
• ☐ I measured my own dark reading D and bright reading B and wrote them down.
• ☐ My LOW and HIGH sit inside that measured range, with LOW below HIGH.
• ☐ Covering the real sensor switched the real LED on; uncovering it switched the LED off.
• ☐ With the reading held between LOW and HIGH, the lamp stayed steady instead of flickering.
• ☐ The LED was off after I pressed stop.

Notebook prompts

• Write down your measured D and B, and the LOW and HIGH you chose.
• Explain hysteresis to someone at home in two sentences.
• Which way does your reading move in bright light, and does that match the expected orientation?

Understand

Safety

• The servo must be powered from an external REGULATED 5 V supply able to deliver at least 1 A, with a suitable insulated connector. That supply may be an extra purchase beyond the kit, and an adult must check it before it is used.
• Never power a servo from a GPIO pin or from the 3V3 OUT pin. A servo pulls far more current than those pins can give, and trying it can damage the board.
• The external supply's positive wire connects to NO Pico pin at all. Not VBUS, not VSYS, not 3V3. The Pico stays powered from the USB cable.
• The only thing shared between the two power systems is ground: the external supply's 0 V connects to Pico GND at physical pin 38. Without that shared ground the servo cannot understand the signal.
• Secure the servo to something solid, such as taping it to a heavy book, before powering it. A loose servo whips around.
• Test with the horn removed, or at least with nothing attached to it. The very first command can make the servo jump suddenly to a new position.
• Actual lead markings on your servo override any colour convention. Red is usually positive and brown or black is usually ground, but check the printed markings or the supplier's documentation.
• If the servo buzzes continuously, gets hot, or is clearly straining against something, cut the motor power immediately.
• Switch BOTH the USB power and the external supply off before any rewiring, and before fitting or removing the horn.

Parts

• 1 × Positional servo from the kit — A positional (angle-holding) servo, not a continuous-rotation one.
• 1 × External regulated 5 V supply, 1 A or more — Possibly an additional purchase. Must be regulated, with a suitable insulated connector. Adult check required.
• 3 × Jumper wires — Signal to GP13, external 0 V to Pico GND, plus the servo's own supply leads.
• 1 × Something to secure the servo — Tape it to a heavy book or clamp it. A loose servo whips about.

Electrical diagram

Connections

Wiring steps

1. Both power sources off: USB unplugged and the external supply switched off and unplugged.
2. Remove the potentiometer and the LDR circuit so the breadboard is clear apart from the Pico.
3. Secure the servo to something heavy. Take the horn off, or make sure nothing is attached to it.
4. Ask an adult to check the external supply: regulated, 5 V, at least 1 A, insulated connector, correct polarity.
5. Connect the servo's positive lead to the external supply's positive output. This touches no Pico pin.
6. Connect the servo's ground lead to the external supply's 0 V.
7. Run a jumper from the external supply's 0 V to Pico GND at physical pin 38. This shared ground is required.
8. Run a jumper from the servo's signal lead to physical pin 17 (GP13).
9. Have the adult check the wiring once more, especially that nothing from the 5 V supply touches a Pico pin.
10. Plug the USB cable in first, then switch the external supply on.

Build steps

1. Let Thonny reconnect and show >>>.
2. Paste the script into a new file and save it to the board as mission-09.py.
3. Keep one hand near the external supply switch for the first run.

Run steps

1. Press Run. The servo moves to the 1500 microsecond centre position. Expect a sudden initial jump.
2. After 2 seconds it steps through 1400, 1500, 1600 and 1500, one second each, printing each pulse width.
3. Watch the horn or the output shaft move a little each way. Note that we do not claim a number of degrees.
4. The script finishes and the finally block stops the output and releases the PWM.
5. If anything buzzes continuously, heats up or strains, switch the external supply off at once.
6. Switch the external supply off, then unplug USB, before touching the wiring again.

mission-09.py

# mission-09.py - Servo motion
# Junior Engineer Lab, Mission 09
# GP13 (physical 17) -> servo SIGNAL lead
# External regulated 5 V (>= 1 A) positive -> servo POSITIVE lead (NO Pico pin)
# External supply 0 V -> servo GROUND lead AND -> Pico GND (physical 38)
# The Pico stays powered from USB. Never power a servo from a GPIO or 3V3 pin.

from machine import Pin, PWM
import time

servo = PWM(Pin(13), freq=50, duty_u16=0)


def command_us(pulse):
    """Clamp to a gentle range, then send the pulse width."""
    pulse = max(1200, min(1800, int(pulse)))
    servo.duty_ns(pulse * 1000)


CENTRE_US = 1500
SEQUENCE = (1400, 1500, 1600, 1500)

try:
    print("Centring. The first movement can jump suddenly.")
    command_us(CENTRE_US)
    time.sleep(2)

    for pulse in SEQUENCE:
        command_us(pulse)
        print("pulse:", pulse, "us")
        time.sleep(1)
finally:
    servo.duty_u16(0)
    servo.deinit()
    print("Signal stopped and PWM released.")
    print("Switch the external supply off before touching the wiring.")

The important lines

servo = PWM(Pin(13), freq=50, duty_u16=0)

50 Hz is what positional servos expect: one pulse every 20 ms. Starting at duty 0 means no pulses until we ask for one.

pulse = max(1200, min(1800, int(pulse)))

The clamp. Whatever number arrives, the servo can only ever be asked for something inside the gentle 1200 to 1800 window.

servo.duty_ns(pulse * 1000)

duty_ns wants nanoseconds, and our pulse is in microseconds, so multiply by 1000.

servo.duty_u16(0) servo.deinit()

Cleanup: stop sending pulses, then release the PWM hardware. A servo with no pulses stops trying to hold position.

Prediction

Question: You forget the jumper from the external supply's 0 V to Pico GND at physical pin 38. The servo has power and the signal wire is connected. What happens?

Expanded answer: The servo misbehaves: usually it twitches randomly, buzzes, or sits there doing nothing. The reason is that a signal voltage only means something compared with a reference. Without a shared 0 V, the Pico's 3.3 V pulses are measured against a reference the servo does not share, so the servo cannot reliably tell a pulse from a gap. Two power systems that must talk to each other always need their grounds connected. If you see random twitching on a servo, check the shared ground first.

Extension challenge

Write a slow sweep: step the pulse from 1200 to 1800 and back in steps of 10 microseconds with a 20 ms delay between steps, so the motion looks smooth instead of jumping. Keep every request going through command_us so the clamp still protects you. Notice how much quieter and gentler the servo sounds when it is not asked to jump.

Troubleshooting

Servo twitches randomly or buzzes without moving properly.

Shared ground missing or loose. Connect the external supply's 0 V to Pico GND at physical pin 38.

Servo does nothing at all.

Check the external supply is actually on and set to 5 V, and that the signal lead is on physical pin 17 (GP13).

The Pico disconnects from Thonny when the servo moves.

The servo is being powered from the board. Move the servo's positive lead to the external supply; it must touch no Pico pin.

Servo gets hot or strains.

Switch the external supply off immediately. Something is blocking the horn, or the servo is being asked for a position outside its travel.

The horn jumps violently on the first command.

That is expected. Secure the servo, start unloaded, and consider the slow sweep from the extension challenge.

Real-hardware acceptance checklist

• ☐ An adult checked the external supply: regulated 5 V, at least 1 A, insulated connector.
• ☐ The external supply's positive wire touches NO Pico pin, including VBUS, VSYS and 3V3.
• ☐ The external supply's 0 V is connected to Pico GND at physical pin 38.
• ☐ The servo signal lead is on GP13, physical pin 17.
• ☐ The servo was secured and unloaded for the first test.
• ☐ The real servo moved to centre and then stepped through 1400, 1500, 1600, 1500.
• ☐ Nothing got hot, buzzed continuously or strained. Both power sources were switched off before any rewiring.

Notebook prompts

• Describe your external supply and who checked it.
• Why must the two grounds be joined but the two positives kept apart?
• What did the motion look like at 1400 compared with 1600?

Understand

Safety

• The servo must be powered from an external REGULATED 5 V supply able to deliver at least 1 A, with a suitable insulated connector. That supply may be an extra purchase beyond the kit, and an adult must check it before it is used.
• Never power a servo from a GPIO pin or from the 3V3 OUT pin. A servo pulls far more current than those pins can give, and trying it can damage the board.
• The external supply's positive wire connects to NO Pico pin at all. Not VBUS, not VSYS, not 3V3. The Pico stays powered from the USB cable.
• The only thing shared between the two power systems is ground: the external supply's 0 V connects to Pico GND at physical pin 38. Without that shared ground the servo cannot understand the signal.
• Secure the servo to something solid, such as taping it to a heavy book, before powering it. A loose servo whips around.
• Test with the horn removed, or at least with nothing attached to it. The very first command can make the servo jump suddenly to a new position.
• Actual lead markings on your servo override any colour convention. Red is usually positive and brown or black is usually ground, but check the printed markings or the supplier's documentation.
• If the servo buzzes continuously, gets hot, or is clearly straining against something, cut the motor power immediately.
• Switch BOTH the USB power and the external supply off before any rewiring, and before fitting or removing the horn.
• The knob is powered from Pico 3V3 OUT at physical pin 36. Keep the 5 V supply well away from the potentiometer.
• Give each potentiometer leg its own breadboard row so you cannot short 3.3 V to ground.

Parts

• 1 × Mission 09 servo circuit — GP13 signal, external regulated 5 V, shared ground at physical pin 38.
• 1 × 10 kΩ potentiometer — Powered from Pico 3.3 V, exactly as in Mission 07.
• 3 × Jumper wires — 3.3 V in, wiper out to GP26, ground out.

Electrical diagram

Connections

Wiring steps

1. Switch the external supply off and unplug USB before touching anything.
2. Keep the entire Mission 09 servo wiring, including the shared ground at physical pin 38.
3. Press the potentiometer into three separate rows.
4. Jumper from physical pin 36 (3V3 OUT) to one outer leg's row.
5. Jumper from the other outer leg's row to the shared ground node.
6. Jumper from the wiper's row to physical pin 31 (GP26).
7. Have an adult confirm again that the 5 V supply positive touches no Pico pin, and that each pot leg has its own row.
8. Plug USB in first, then switch the external supply on.

Build steps

1. Paste the script into a new file and save it to the board as mission-10.py.
2. Before running, work out by hand what pulse a reading of 0, 32768 and 65535 should produce.
3. Turn the knob to one end so you know where the servo will start.

Run steps

1. Press Run. The Shell starts printing a reading and a pulse ten times a second.
2. Turn the knob slowly. The servo should follow your hand, and the printed pulse should sweep between 1200 and 1800.
3. Check the ends: fully one way should print close to 1200, fully the other close to 1800.
4. Turn the knob quickly and listen. Fast changes make the servo work much harder.
5. Press stop, then switch the external supply off before touching the wiring.

mission-10.py

# mission-10.py - Robot control knob
# Junior Engineer Lab, Mission 10
# Knob (Pico 3.3 V side):
#   3V3 OUT (physical 36) -> pot outer leg A
#   pot centre wiper      -> GP26 / ADC0 (physical 31)
#   pot outer leg B       -> shared ground node -> GND (physical 38)
# Servo (external 5 V side):
#   GP13 (physical 17)    -> servo SIGNAL lead
#   external regulated 5 V (>= 1 A) -> servo POSITIVE lead (NO Pico pin)
#   external supply 0 V   -> servo GROUND lead AND Pico GND (physical 38)

from machine import Pin, PWM, ADC
import time

servo = PWM(Pin(13), freq=50, duty_u16=0)
knob = ADC(Pin(26))


def command_us(pulse):
    """Clamp to a gentle range, then send the pulse width."""
    pulse = max(1200, min(1800, int(pulse)))
    servo.duty_ns(pulse * 1000)


UPDATE_DELAY_MS = 100

try:
    while True:
        reading = knob.read_u16()

        # Map 0..65535 onto 1200..1800 microseconds.
        # Multiply BEFORE dividing, or integer division would give 0.
        pulse = 1200 + reading * 600 // 65535

        command_us(pulse)
        print("reading:", reading, " pulse:", pulse, "us")

        time.sleep_ms(UPDATE_DELAY_MS)
except KeyboardInterrupt:
    pass
finally:
    servo.duty_u16(0)
    servo.deinit()
    print("Signal stopped and PWM released.")
    print("Switch the external supply off before touching the wiring.")

The important lines

pulse = 1200 + reading * 600 // 65535

The map. Start at the bottom of the window, then add the knob's share of the 600 microsecond span. Multiplying first is essential.

//

Integer division: throws away the fraction so the pulse is a clean whole number of microseconds.

command_us(pulse)

Everything still goes through the clamp, so even a wrong formula or a noisy reading cannot push the servo outside 1200 to 1800.

time.sleep_ms(UPDATE_DELAY_MS)

Ten updates a second. Updating faster makes the servo chase analog noise, which sounds buzzy and wears the gears.

Prediction

Question: What pulse width does the formula give for a reading of exactly 32768, and what would happen if you wrote reading // 65535 * 600 instead?

Expanded answer: For 32768: 32768 * 600 = 19660800, and 19660800 // 65535 = 299, so the pulse is 1499 microseconds, essentially centre. That is exactly what you want from a knob at the halfway point. Writing reading // 65535 * 600 would be a disaster: 32768 // 65535 is 0 because integer division throws the fraction away, so the result is 1200 + 0 = 1200 for every reading except the absolute maximum. The servo would sit at one end and ignore the knob. In integer maths, always multiply before you divide.

Extension challenge

Stop the servo chasing noise. Only send a new command when the newly mapped pulse differs from the last one you sent by at least 5 microseconds, otherwise skip it. Print a line when you skip, so you can see how often small noise was making the servo move for no reason.

Troubleshooting

Servo sits at one end and ignores the knob.

The division happens before the multiplication. Write reading * 600 // 65535.

Servo buzzes constantly and jitters.

It is chasing analog noise. Try the extension's minimum-change rule, or average several readings.

Knob reading is stuck.

A pot leg is in the wrong row, or the wiper jumper is not on physical pin 31. Each leg needs its own row.

Servo does nothing but readings look right.

Check the external supply is on and that the shared ground from its 0 V to physical pin 38 is connected.

Board resets when the servo moves.

Servo power is coming from the board. The external supply positive must touch no Pico pin.

Real-hardware acceptance checklist

• ☐ The knob is powered from Pico 3V3 OUT at physical pin 36, with each leg in its own row.
• ☐ The servo is powered only from the external regulated 5 V supply, which touches no Pico pin.
• ☐ The external supply's 0 V is connected to Pico GND at physical pin 38.
• ☐ Turning the real knob moved the real servo smoothly in both directions.
• ☐ The printed pulse reached close to 1200 at one end and close to 1800 at the other.
• ☐ The servo did not overheat or strain, and both supplies were switched off before rewiring.

Notebook prompts

• What pulse did you see at each end of the knob's travel?
• Explain why multiplying before dividing matters here.
• Why can we not say what angle the servo is really at?

Understand

Safety

• The servo must be powered from an external REGULATED 5 V supply able to deliver at least 1 A, with a suitable insulated connector. That supply may be an extra purchase beyond the kit, and an adult must check it before it is used.
• Never power a servo from a GPIO pin or from the 3V3 OUT pin. A servo pulls far more current than those pins can give, and trying it can damage the board.
• The external supply's positive wire connects to NO Pico pin at all. Not VBUS, not VSYS, not 3V3. The Pico stays powered from the USB cable.
• The only thing shared between the two power systems is ground: the external supply's 0 V connects to Pico GND at physical pin 38. Without that shared ground the servo cannot understand the signal.
• Secure the servo to something solid, such as taping it to a heavy book, before powering it. A loose servo whips around.
• Test with the horn removed, or at least with nothing attached to it. The very first command can make the servo jump suddenly to a new position.
• Actual lead markings on your servo override any colour convention. Red is usually positive and brown or black is usually ground, but check the printed markings or the supplier's documentation.
• If the servo buzzes continuously, gets hot, or is clearly straining against something, cut the motor power immediately.
• Switch BOTH the USB power and the external supply off before any rewiring, and before fitting or removing the horn.
• Light PAPER FLAP only. No wearing, no heavy printed faceplate, no mounting on a head or body.
• Calibrate with the servo unloaded and the flap off, before anything is attached.
• Both power sources off before fitting the flap, fitting the horn, or any rewiring.
• There is no electronic emergency stop in this design. Keep the external supply switch within reach; cutting motor power is the immediate stop.
• The program cannot see a button press while the flap is moving. Do not rely on the button to stop a movement.

Parts

• 1 × Mission 09 servo circuit — GP13 signal, external regulated 5 V, shared ground at physical pin 38.
• 1 × Pushbutton on GP15 — With internal pull-up, as in Mission 04. One leg from each of two different internal pairs.
• 1 × Red LED and 1 kΩ resistor on GP16 — Shows the commanded state.
• 1 × Light paper flap — Thin paper or card, as light as you can make it. Nothing heavy, nothing worn.
• 1 × Tape and a heavy base — To secure the servo to the table so it cannot move itself around.

Electrical diagram

Connections

Wiring steps

1. Switch the external supply off and unplug USB. Remove the potentiometer completely.
2. Keep the servo circuit from Mission 09, including the shared ground at physical pin 38.
3. Rebuild the GP16 LED branch with its 1 kΩ resistor, cathode to the shared ground node.
4. Rebuild the GP15 button, straddling the trench, contact A to physical pin 20 and contact B to the shared ground node.
5. Secure the servo to a heavy base with tape. Leave the horn off or unloaded for now.
6. Have an adult check the whole build, especially that the 5 V positive touches no Pico pin.
7. Plug USB in first, then switch the external supply on.

Build steps

1. Paste the script into a new file and save it to the board as mission-11.py.
2. First run with the servo UNLOADED and no flap fitted. Watch how far the horn travels between CLOSED_US and OPEN_US.
3. Switch the external supply off. Fit the horn and tape on a light paper flap.
4. By hand, with power off, check the flap can swing freely between those two positions without catching.
5. Narrow CLOSED_US and OPEN_US until the travel is exactly what you want. Keep both inside 1200 to 1800; the asserts will stop you otherwise.
6. Save your calibrated numbers and write them in your notebook so you can rebuild the mechanism later.

Run steps

1. Press Run. The flap moves once to the closed position. The first move may jump.
2. Press the button once. The flap glides open in small steps and the LED lights.
3. Press once more. The flap glides closed and the LED goes out.
4. Now HOLD the button down. The flap must move exactly once, not flutter back and forth.
5. Try gently blocking the flap with a finger and notice that the program cannot tell. Then stop blocking it.
6. Press stop. The finally block switches the LED off and releases the PWM.
7. Switch the external supply off, then unplug USB, before touching the mechanism.

mission-11.py

# mission-11.py - Tabletop mask mechanism (capstone)
# Junior Engineer Lab, Mission 11
#
# TABLETOP MECHANISM MOVING A LIGHT PAPER FLAP ONLY.
# Not for wearing. No heavy faceplate. Nothing mounted on a head or body.
#
# GP13 (physical 17) -> servo SIGNAL lead
# GP15 (physical 20) -> button contact A, contact B -> shared ground node
# GP16 (physical 21) -> 1 kohm -> LED -> shared ground node
# External regulated 5 V (>= 1 A) -> servo POSITIVE lead (NO Pico pin)
# External supply 0 V -> servo GROUND lead AND Pico GND (physical 38)

from machine import Pin, PWM
import time

# Calibrate these for YOUR mechanism, unloaded first.
# Both must stay inside the 1200..1800 clamp window.
CLOSED_US = 1400
OPEN_US = 1600

assert 1200 <= CLOSED_US <= 1800, "CLOSED_US must be inside the clamp window"
assert 1200 <= OPEN_US <= 1800, "OPEN_US must be inside the clamp window"

servo = PWM(Pin(13), freq=50, duty_u16=0)
button = Pin(15, Pin.IN, Pin.PULL_UP)
led = Pin(16, Pin.OUT)

STEP_US = 10
STEP_DELAY_MS = 30
DEBOUNCE_MS = 30

position = CLOSED_US
opened = False


def command_us(pulse):
    """Clamp to a gentle range, then send the pulse width."""
    pulse = max(1200, min(1800, int(pulse)))
    servo.duty_ns(pulse * 1000)


def move_slowly(target):
    """Walk the stored position toward the target in small steps."""
    global position
    while position != target:
        # min() makes the final step exactly the distance remaining,
        # so we land on the target instead of overshooting it.
        step = min(STEP_US, abs(target - position))
        if target > position:
            position = position + step
        else:
            position = position - step
        command_us(position)
        time.sleep_ms(STEP_DELAY_MS)


try:
    print("Closing the flap. The first movement can jump suddenly.")
    command_us(position)
    led.off()
    time.sleep(1)
    print("Ready. Press the button to toggle the flap.")

    while True:
        if button.value() == 0:
            time.sleep_ms(DEBOUNCE_MS)
            if button.value() == 0:
                # A confirmed press. Toggle the commanded state.
                opened = not opened
                move_slowly(OPEN_US if opened else CLOSED_US)

                # The LED shows the COMMANDED state, not a measured position.
                led.value(1 if opened else 0)
                print("flap commanded:", "OPEN" if opened else "CLOSED",
                      " pulse:", position, "us")

                # Wait for release so holding the button cannot retrigger.
                while button.value() == 0:
                    time.sleep_ms(1)
                time.sleep_ms(DEBOUNCE_MS)

        time.sleep_ms(5)
except KeyboardInterrupt:
    pass
finally:
    led.off()
    servo.duty_u16(0)
    servo.deinit()
    print("LED off, signal stopped, PWM released.")
    print("Switch the external supply off before touching the mechanism.")

The important lines

assert 1200 <= CLOSED_US <= 1800

Refuses to run with endpoint constants outside the clamp window, so a typo cannot push the mechanism past its safe travel.

step = min(STEP_US, abs(target - position))

Steps of 10 microseconds, except the last one which is exactly the remaining distance. That is how we land precisely on the target.

opened = not opened

The toggle itself. One confirmed press flips the commanded state exactly once.

while button.value() == 0: time.sleep_ms(1) time.sleep_ms(DEBOUNCE_MS)

Waits for the finger to come off, then debounces. Without this, holding the button would flip the state again and again.

led.value(1 if opened else 0)

The LED reports what we commanded. It is not evidence that the flap actually arrived, because there is no position feedback.

finally: led.off(); servo.duty_u16(0); servo.deinit()

Full cleanup. The light goes out and the servo stops being told to hold a position, even if you stop the program mid-movement.

Prediction

Question: You delete the 'wait for release' loop and keep everything else. You press and hold the button for two seconds. What happens to the flap and the LED?

Expanded answer: The flap thrashes. The main loop comes round again while your finger is still down, sees a 0, treats it as a brand new press, and flips the state again. So the flap opens, closes, opens, closes for as long as you hold, with the LED flickering along with it. Each full movement takes about a second here, so you would get roughly two toggles per held second, and the gearbox and paper take a beating. Waiting for the release is what turns a level (held down) into an event (one press).

Extension challenge

Add a second button on a free GPIO pin, with its own internal pull-up, that acts as a 'park' button: it always commands the closed position regardless of the current state, and sets opened back to False. Reuse move_slowly, keep the clamp, and keep the full cleanup in finally. Think about what happens if both buttons are pressed together, and write down your decision before you code it.

Troubleshooting

Flap flutters back and forth while I hold the button.

The wait-for-release loop is missing or the debounce was removed.

AssertionError on startup.

CLOSED_US or OPEN_US is outside 1200 to 1800. Fix your calibration constants.

Flap jumps instead of gliding.

STEP_US is too large, or the code is calling command_us directly instead of move_slowly.

Paper flap catches or tears.

Switch the external supply off, then narrow CLOSED_US and OPEN_US so the travel is smaller. Check the flap's path by hand with power off.

Servo buzzes while holding a position.

It is straining. Switch the external supply off and reduce the load, or narrow the travel. A paper flap should never make a servo strain.

Button press does nothing while the flap is moving.

That is expected and documented: the program is blocked inside move_slowly and cannot see the input until the movement finishes.

Real-hardware acceptance checklist

• ☐ The mechanism moves a LIGHT PAPER FLAP on a table. Nothing is worn and no heavy faceplate is attached.
• ☐ I calibrated with the servo unloaded first, then fitted the flap with both power sources off.
• ☐ My CLOSED_US and OPEN_US are inside 1200 to 1800 and give travel that does not make the flap catch.
• ☐ One real press opened the flap smoothly and the LED lit; the next press closed it and the LED went out.
• ☐ Holding the button down moved the flap exactly once, with no fluttering.
• ☐ The servo never buzzed, strained or got hot, and the external supply switch stayed within reach.
• ☐ After stopping, the LED was off and the servo was no longer being driven.
• ☐ I understand there is no position feedback and no electronic emergency stop: cutting motor power is the immediate stop.

Notebook prompts

• Write down your calibrated CLOSED_US and OPEN_US and how you chose them.
• What did you learn about moving in steps instead of jumping?
• List three things this mechanism cannot do, and what a real design review would have to cover.