Body simulator

# labs/body_sim.py
DEFAULT_DEVICES: dict = {
    "arm_servo": {"pin": 18, "type": "pwm", "enabled": False, "angle": 0},
    "status_led": {"pin": 17, "type": "gpio", "enabled": False, "state": "off"},
}

def simulate_move_servo(config: dict, device_name: str, angle: int) -> None:
    config[device_name]["angle"] = angle
    print(f"[SIM] {device_name} moved to {config[device_name]['angle']} degrees")

simulate_move_servo(DEFAULT_DEVICES, "arm_servo", 90)

$ uv run python labs/body_sim.py
[SIM] arm_servo moved to 90 degrees

Two decisions to notice. Each device is an entry in a dict, with its pin, its type, and its current state as plain fields: her body, as far as the logic is concerned, is data you can print, save, and diff. And the function takes the config as its first argument instead of reaching for a hardware library, so "moving" a servo means mutating a dict and announcing it. That print line is the entire difference between this backend and the real one.

def simulate_move_servo(config: dict, device_name: str, angle: int) -> None:
    if device_name not in config:
        print(f"Device not found: {device_name}")
        return
    config[device_name]["angle"] = max(0, min(180, angle))
    print(f"[SIM] {device_name} moved to {config[device_name]['angle']} degrees")

simulate_move_servo(DEFAULT_DEVICES, "arm_servo", 250)
simulate_move_servo(DEFAULT_DEVICES, "arm_servo", -30)
simulate_move_servo(DEFAULT_DEVICES, "gripper", 45)

$ uv run python labs/body_sim.py
[SIM] arm_servo moved to 180 degrees
[SIM] arm_servo moved to 0 degrees
Device not found: gripper

max(0, min(180, angle)) pins any number into the range 0 to 180: for 250, the inner min yields 180 and the outer max keeps it; for -30, the min passes -30 through and the max raises it to 0. The clamp lives inside the function, not at the call sites, because call sites multiply: a typo, a bad sensor reading, or a confused language model can all produce an unsafe angle, and none of them can get past a limit enforced where the value is applied. The membership guard above it turns a would-be KeyError into a readable message, since asking for a device she does not have should be a fact, not a crash.

import copy
import json
from pathlib import Path

DEVICE_CONFIG = Path("configs/devices.json")

def load_device_config(path: Path) -> dict:
    if path.exists():
        with open(path) as f:
            return json.load(f)
    return copy.deepcopy(DEFAULT_DEVICES)

def save_device_config(config: dict, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        json.dump(config, f, indent=2)

config = load_device_config(DEVICE_CONFIG)
simulate_move_servo(config, "arm_servo", 135)
save_device_config(config, DEVICE_CONFIG)
print(f"angle on disk: {json.loads(DEVICE_CONFIG.read_text())['arm_servo']['angle']}")

$ uv run python labs/body_sim.py
[SIM] arm_servo moved to 135 degrees
angle on disk: 135

Chapter 22 taught the load-or-defaults pattern for her preferences; here it keeps the simulator's last commanded angle. The input is the requested angle; the clamp turns it into the command stored in angle. In this simulator, assigning that number is the whole move. On hardware, a saved command says nothing about a stalled joint or an arm somebody moved while power was off. Physical position remains unknown until a suitable measurement or supervised startup establishes it. No position feedback reaches this program.

Neither zero nor the saved command is a safe automatic restart target. Keep motion disabled while an operator checks clearance and supports the mechanism as needed; use the selected hardware's reviewed startup or homing procedure before enabling ordinary moves. An open-loop hobby servo needs supervision, and even its first pulse can cause movement. Persisted state helps diagnostics; it does not replace that procedure or an independent stop. One software detail: the fallback is copy.deepcopy, not .copy(), because a shallow copy shares the nested per-device dicts, and mutating the "copy" would silently rewrite your defaults. Exercise 3 makes that bug visible.

# labs/body_sim.py — full file
import copy
import json
import random
from pathlib import Path

DEVICE_CONFIG = Path("configs/devices.json")

DEFAULT_DEVICES: dict = {
    "arm_servo": {"pin": 18, "type": "pwm", "enabled": False, "angle": 0},
    "status_led": {"pin": 17, "type": "gpio", "enabled": False, "state": "off"},
}

def load_device_config(path: Path) -> dict:
    if path.exists():
        with open(path) as f:
            return json.load(f)
    return copy.deepcopy(DEFAULT_DEVICES)

def save_device_config(config: dict, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        json.dump(config, f, indent=2)

def simulate_move_servo(config: dict, device_name: str, angle: int) -> None:
    if device_name not in config:
        print(f"Device not found: {device_name}")
        return
    config[device_name]["angle"] = max(0, min(180, angle))
    print(f"[SIM] {device_name} moved to {config[device_name]['angle']} degrees")

def simulate_read_distance() -> float:
    return round(random.uniform(5.0, 50.0), 1)

def main() -> None:
    config = load_device_config(DEVICE_CONFIG)
    simulate_move_servo(config, "arm_servo", 90)
    print(f"[SIM] distance sensor: {simulate_read_distance()} cm")
    save_device_config(config, DEVICE_CONFIG)
    print(f"State saved to {DEVICE_CONFIG}")

if __name__ == "__main__":
    main()

$ uv run python labs/body_sim.py
[SIM] arm_servo moved to 90 degrees
[SIM] distance sensor: 23.7 cm
State saved to configs/devices.json

The distance figure is random by design, so yours will differ on every run. simulate_read_distance is the sensor side of the same idea: code that reacts to "someone is closer than 30 cm" can be written and tested against plausible fake readings long before an ultrasonic module exists to produce real ones.