[rmncardoso]

Fix to parts 2, 3, 5 and 5.5 of #4749 · roadmap #3818

In one paragraph

On macOS, MUJOCO_GL=glfw renders on #4789's strands-gl ended the process (SIGTRAP; GLFW windows need the main thread); now they stay on the caller's thread. Robot(id=) never reached the Feetech driver; now it names the LeRobot file; an id without one loads none, warning beside other files. calibrate() saved where the next connect does not look; now it saves over the file it loaded, but with save=True (the default) records nothing over a guess (no id, the only file there, maybe another arm's). As in LeRobot, it asks before torque goes off, zeroes offsets after the middle pose, gives wrist_roll the full turn, and refuses a sweep leaving a joint without a range; the refusal puts the servos' offsets back. At hz=inf or nan, run() and subscribe("state") ran unpaced; FeetechDriver.write() turned torque on before refusing a NaN. Each now refuses first.

Measured

Fake Feetech bus; dev cc15d9a.

gate	dev	this PR
Robot(id="my_arm") beside another arm's file: shoulder_pan 1.0 rad; next connect after calibrate(), lower limit (e_calibration.py)	goal 2700; encoder 1325	2581; 2148
Robot(id="left") beside only LeRobot's tutorial file: shoulder_pan's lower limit (e_calibration.py)	loads it: 1024	loads none, warns: 796, 228 counts past the file's stop
arm B, no id, calibrate() on arm A's file (e_calibration.py)	records	refused, nothing sent
calibrate(), a file loaded (e_calibration.py)	torque off, 6 offset writes, unasked	asks; nothing written
wrist_roll still; turned (e_calibration.py)	2047..2047; 1847..2247	0..4095
still gripper: read(); shoulder_pan's upper limit (stop 3072), same session; next connect (e_calibration.py)	division by zero; 2548; 3373	ValueError, nothing saved, offsets back: finite; 3072; 3072
no sweep (e_no_sweep.py)	goal 4096	ValueError, offsets back
run(hz=inf); subscribe("state", hz=inf); NaN to FeetechDriver.write() (e_rates_write.py)	51 frames in 0.007 s; 5382 reads in 0.2 s; torque on	ValueError, nothing sent

Not in this PR

GLFW off the main thread still traps. A Ctrl-C after the middle pose or a failed save leaves new offsets under the old file, 301 counts off at the next connect, which, unlike LeRobot's, never compares them (e_sweep.py, k_failed_save.py). wrist_roll's 0..4095, as in LeRobot's files, maps onto the description's ±2.79 rad: the real wrist turns 65° where the twin shows 57°, and 180° at its limit (k_wrist_roll_map.py, k_wrist_twin.py). Simulation.run(hz=) checks no rate.

Questions

Should a fresh calibrate() save to so_follower/<id>.json, and Enter write the kept file to the servos, as LeRobot 0.6 does?

Evidence

macOS 26.7.1, Python 3.12.10, MuJoCo 3.16.0, LeRobot at the pinned 53feaef3. "dev" is cc15d9a's
strands_robots/ and tests/ from git archive, run from that root; each script runs from the repo root unless
it takes the root as an argument. HF_LEROBOT_CALIBRATION always points at a temp dir. The machine was shared,
so timings are only orders of magnitude.

GLFW. e_gl.sh, the render in a child process per MUJOCO_GL (133 is 128 + SIGTRAP):

#!/bin/zsh
# macOS, from the repo root: tests/test_render_thread.py's _PROBE in a child process per MUJOCO_GL value
# ('' = unset: CGL).
PROBE='
from strands_robots import Robot, Simulation
sim = Simulation()
sim.camera("cam", size=(64, 48), attach=Robot("so101", sim=sim))
try:
    print(sim.render("cam").shape)
except RuntimeError as e:
    print(str(e).split(":")[0])
sim.close()
'
for gl in glfw '' disable; do
  out=$(MUJOCO_GL=$gl python -c "$PROBE" 2>/dev/null); rc=$?
  echo "MUJOCO_GL=${gl:-unset}: exit $rc, printed '${out}'"
done

dev cc15d9a7
MUJOCO_GL=glfw: exit 133, printed ''
MUJOCO_GL=unset: exit 0, printed '(48, 64, 3)'
MUJOCO_GL=disable: exit 0, printed 'rendering unavailable'
this PR
MUJOCO_GL=glfw: exit 0, printed '(48, 64, 3)'
MUJOCO_GL=unset: exit 0, printed '(48, 64, 3)'
MUJOCO_GL=disable: exit 0, printed 'rendering unavailable'

The other callers of the GL thread, python run_child.py glfw python gl_child.py <root> <mode>, which starts the
child with PYTHONPATH unset and a 60 s cap; the table shows the child's returncode from Python's subprocess
(-5: SIGTRAP):

mode	dev cc15d9a	this PR	269d54c, before #4789
main: a main-thread render	-5	0: (48, 64, 3), GLContext from mujoco.glfw	0
task: that, then a background start()	-5	0: the run done in 3 steps	0
first-off-main: a first render on a worker thread	-5	-5	-5
scene-off-main: a main-thread render, then a worker adds a robot	-5	-5	-5

With MUJOCO_GL unset (CGL), scene-off-main returns 0 on all three, its second main-thread render (48, 64, 3).

import sys, threading
sys.path.insert(0, sys.argv[1])
mode = sys.argv[2]
from strands_robots import Robot, Simulation
sim = Simulation()
arm = Robot("so101", sim=sim)
sim.camera("cam", size=(64, 48), attach=arm)
try:
    if mode in ("main", "task", "scene-off-main"):
        img = sim.render("cam")
        import mujoco.gl_context as g
        print(f"main-thread render {img.shape}; GLContext from {getattr(getattr(g, 'GLContext', None), '__module__', None)}", flush=True)
    if mode == "task":
        task = arm.start(lambda o: o.joints.positions, steps=3)
        task._thread.join(20)
        print(f"background run: {task.status}; result {task.result and task.result.steps} steps", flush=True)
    if mode == "first-off-main":
        out = []
        t = threading.Thread(target=lambda: out.append(sim.render("cam").shape), name="worker")
        t.start(); t.join(20)
        print(f"worker-thread render: {out}", flush=True)
    if mode == "scene-off-main":  # the scene rebuild frees the main thread's renderer on the worker
        t = threading.Thread(target=lambda: Robot("so101", sim=sim, position=[0.5, 0, 0]), name="worker")
        t.start(); t.join(20)
        print(f"worker added a robot; main-thread render again {sim.render('cam').shape}", flush=True)
except Exception as e:
    print(f"{type(e).__name__}: {str(e)[:160]}", flush=True)
sim.close()
print("closed", flush=True)

Where scene-off-main traps on this PR: backend.load() (backend.py:92) clears the renderers through
on_gl_thread, which runs inline on the worker that added the robot, and Renderer.__del__ reaches
glfw.destroy_window there. MUJOCO_GL=glfw python gl_trap_stack.py <root>, paths shortened:

# The scene-off-main child with a SIGTRAP traceback: argv[1] = root. Run under MUJOCO_GL=glfw.
import faulthandler, signal, sys, threading
faulthandler.register(signal.SIGTRAP, all_threads=True, chain=True)
sys.path.insert(0, sys.argv[1])
from strands_robots import Robot, Simulation
sim = Simulation()
arm = Robot("so101", sim=sim)
sim.camera("cam", size=(64, 48), attach=arm)
print("main render", sim.render("cam").shape, flush=True)
t = threading.Thread(target=lambda: Robot("so101", sim=sim, position=[0.5, 0, 0]), name="worker")
t.start(); t.join(20)
print("worker added a robot", flush=True)

main render (48, 64, 3)
Current thread 0x000000016e463000 (most recent call first):
  File "<site-packages>/glfw/__init__.py", line 1281 in destroy_window
  File "<site-packages>/mujoco/glfw/__init__.py", line 37 in free
  File "<site-packages>/mujoco/rendering/classic/renderer.py", line 335 in close
  File "<site-packages>/mujoco/rendering/classic/renderer.py", line 349 in __del__
  File "<root>/strands_robots/_gl.py", line 64 in on_gl_thread
  File "<root>/strands_robots/simulation/backends/mujoco/backend.py", line 92 in load
  File "<root>/strands_robots/simulation/_sceneops.py", line 71 in _reload
  File "<root>/strands_robots/simulation/_sceneops.py", line 79 in _grow
  File "<root>/strands_robots/simulation/_sceneops.py", line 65 in add
  File "<root>/strands_robots/robot/robot.py", line 89 in __init__
  File "<scripts>/gl_trap_stack.py", line 10 in <lambda>
  File "<python>/threading.py", line 1012 in run
  File "<python>/threading.py", line 1075 in _bootstrap_inner
  File "<python>/threading.py", line 1032 in _bootstrap

Thread 0x00000001edbba1c0 (most recent call first):
  File "<python>/threading.py", line 1169 in _wait_for_tstate_lock
  File "<python>/threading.py", line 1153 in join
  File "<scripts>/gl_trap_stack.py", line 11 in <module>
exit 133

No GLFW child is in the suite: when this Mac's session went idle on 2026-10-18 (pmset -g assertions:
UserIsActive 0), a plain glfw.init() hung and such a test timed out on every commit. The routing test pins the
decision on every platform, and a MUJOCO_GL=disable child pins "rendering unavailable".

Calibration. e_calibration.py:

# From the repo root: python e_calibration.py. The suite's FakeSerial; HF_LEROBOT_CALIBRATION is a temp dir.
import json, os, shutil, sys, tempfile, warnings
sys.path[:0] = [".", "tests"]
os.environ["HF_LEROBOT_CALIBRATION"] = root = tempfile.mkdtemp()
import numpy as np
from test_drivers import CAL, FakeSerial
from strands_robots import Description, Robot
from strands_robots.robot.drivers import feetech as ft
from strands_robots.robot.drivers.feetech import driver as ftd

OTHER = {k: dict(v, range_min=1124, range_max=3172) for k, v in CAL.items()}  # another arm's file
AT_120 = {k: dict(v, homing_offset=120) for k, v in CAL.items()}
LO, UP = Description.load("so101").limits["shoulder_pan"]  # shoulder_pan's lower and upper limits, rad
LOWER = np.array([LO, 0, 0, 0, 0, 0])

def disk(files):  # {"so_follower/my_arm.json": calibration}, under robots/ as LeRobot files them
    shutil.rmtree(os.path.join(root, "robots"), ignore_errors=True)
    for rel, cal in files.items():
        p = os.path.join(root, "robots", rel)
        os.makedirs(os.path.dirname(p), exist_ok=True)
        json.dump(cal, open(p, "w"))

def arm(s, **kw):
    return ft.FeetechDriver(Description.load("so101"), port="/dev/fake", bus=ft.FeetechBus("/dev/fake", serial=s), **kw)

def goal(s):
    return int.from_bytes(s.regs[1][ft.REG_GOAL_POSITION : ft.REG_GOAL_POSITION + 2], "little")

def lower(d, s):  # shoulder_pan to its lower limit: the goal sent and where the encoder ends
    d.write(LOWER)
    return f"lower limit: goal {goal(s)}, encoder {s.actual[1]}"

def upper(d, s):  # shoulder_pan to its upper limit: the goal sent and where the encoder ends
    d.write(np.array([UP, 0, 0, 0, 0, 0]))
    return f"upper limit: goal {goal(s)}, encoder {s.actual[1]}"

def short(p):
    return p and os.path.relpath(p, os.path.join(root, "robots"))

def files():
    return sorted(short(os.path.join(d, f)) for d, _, fs in os.walk(os.path.join(root, "robots")) for f in fs)

def writes(s):
    w = [f for f in s.frames if f[4] in (ft.WRITE, ft.SYNC_WRITE)]
    return f"torque frames {[f[8] for f in w if f[5] == ft.REG_TORQUE_ENABLE]}, homing writes {sum(f[5] == ft.REG_HOMING_OFFSET for f in w)}"

def read(d):
    try:
        return f"finite: {bool(np.isfinite(d.read().positions).all())}"
    except Exception as e:  # noqa: BLE001
        return f"{type(e).__name__}: {e}"

class Sweep(FakeSerial):  # the operator's sweep: +-200 around the middle, one end per SYNC_READ; `still` servos stay
    moving = flip = False
    still = ()

    def write(self, data):
        if self.moving and data[4] == ft.SYNC_READ:
            self.flip = not self.flip
            self.actual.update({i: 2348 + (200 if self.flip else -200) for i in self.actual if i not in self.still})
        super().write(data)

def operator(s, answers, seen):  # answers in order ("^C" raises); the MIDDLE pose is encoder 2348
    it = iter(answers)

    def prompt(msg):
        seen.append(writes(s))
        a = next(it, "")
        if a == "^C":
            raise KeyboardInterrupt
        if "MIDDLE" in msg:
            s.actual.update(dict.fromkeys(s.actual, 2348))
        s.moving = s.moving or "full range" in msg
        return a

    return prompt

def calibrate(d, s, answers):  # "c" answers this PR's question; on dev, which asks none, the middle-pose prompt eats it
    n0 = len(s.frames)
    try:
        cal = d.calibrate(interactive=True, prompt=operator(s, answers, []), sweep_seconds=0.05)
        return f"homing {cal.joints['shoulder_pan'].homing_offset}, saved to {short(d.calibration_source)}"
    except (RuntimeError, ValueError) as e:
        sent = sum(f[4] in (ft.WRITE, ft.SYNC_WRITE) for f in s.frames[n0:])
        return f"{type(e).__name__}: {str(e).replace(root, '<root>')}; write frames sent {sent}"
    finally:
        s.moving = False

for rid, given, rad in (
    ("my_arm", {"so_follower/my_arm.json": CAL, "so_follower/other_arm.json": OTHER}, 1.0),
    ("my_arm", {"so_follower/other_arm.json": OTHER}, 1.0),
    ("left", {"so_follower/my_awesome_follower_arm.json": CAL}, LO),  # LeRobot's tutorial id; the lower limit
):
    disk(given)
    s = FakeSerial()
    ftd.FeetechBus = lambda port, baud: ft.FeetechBus(port, serial=s)
    with warnings.catch_warnings(record=True) as seen:
        warnings.simplefilter("always")
        real = Robot("so101", port="/dev/fake", id=rid, twin=False)
    real.act({"shoulder_pan": rad})
    said = [str(w.message).replace(root, "<root>") for w in seen]
    print(f"id: {sorted(given)} -> Robot(id={rid!r}) loads {short(real.body.calibration_source)}; shoulder_pan={rad:.2f}: goal {goal(s)}; warnings {said}")
    real.close()

disk({"so_follower/my_arm.json": CAL})
s = Sweep()
d = arm(s, robot_id="my_arm")
print(f"save: session 1, id 'my_arm', loads {short(d.calibration_source)}; {lower(d, s)}")
print(f"save: calibrate(): {calibrate(d, s, ['c'])}; servos hold {s._homing(1)}; files {files()}")
d2 = arm(s, robot_id="my_arm")
print(f"save: session 2 loads {short(d2.calibration_source)} (homing {d2.calibration.joints['shoulder_pan'].homing_offset}); {lower(d2, s)}")

disk({"so_follower/arm_a.json": CAL})  # two arms, one root: only arm A's file is on disk; A's servos hold homing 0
b = Sweep()
rb = arm(b)
print(f"two arms: B, no id, loads {short(rb.calibration_source)}; B's calibrate(): {calibrate(rb, b, ['c'])}; files {files()}")
a = FakeSerial()
for kw in ({}, {"robot_id": "arm_a"}):
    ra = arm(a, **kw)
    print(f"two arms: A, {'id ' + repr(kw['robot_id']) if kw else 'no id'}, loads {short(ra.calibration_source)}; {lower(ra, a)}")
rb2 = arm(b)
print(f"two arms: B again, no id, loads {short(rb2.calibration_source)}; {lower(rb2, b)}")

disk({"so_follower/my_arm.json": CAL})  # one arm, calibrated by LeRobot as "my_arm": the only file there
s = Sweep()
d = arm(s)
print(f"guess: no id, loads {short(d.calibration_source)}; calibrate(): {calibrate(d, s, ['c'])}; servos hold {s._homing(1)}")
d = arm(s, robot_id="my_arm")
print(f"guess: then id 'my_arm', calibrate(): {calibrate(d, s, ['c'])}; files {files()}")
for kw in ({"robot_id": "my_arm"}, {}):
    d2 = arm(s, **kw)
    print(f"guess: next connect, {'id' if kw else 'no id'}, loads {short(d2.calibration_source)}; {lower(d2, s)}")

for answers in ([""], ["^C"], ["c", "^C"]):
    disk({"so_follower/my_arm.json": AT_120})
    s = Sweep()
    for i in s.regs:
        s.regs[i][ft.REG_HOMING_OFFSET : ft.REG_HOMING_OFFSET + 2] = ft.encode_sm(120, 11)
    d, seen = arm(s, robot_id="my_arm"), []
    try:
        d.calibrate(interactive=True, prompt=operator(s, answers, seen), sweep_seconds=0.05)
        how = "returned"
    except KeyboardInterrupt:
        how = "Ctrl-C"
    print(f"ask {answers}: {how} after {len(seen)} prompt(s); before the first answer: {seen[0]}; servos hold {s._homing(1)}, the file 120")

for still, what in (({5}, "wrist_roll still, as LeRobot asks"), (set(), "every joint moves")):
    disk({})
    s = Sweep()
    s.still = still
    d = arm(s, robot_id="my_arm")
    said = calibrate(d, s, [])
    w = d.calibration.joints["wrist_roll"]
    print(f"wrist_roll: sweep, {what}: calibrate(): {said}; wrist_roll range {w.range_min}..{w.range_max}; read(): {read(d)}")

disk({"so_follower/my_arm.json": CAL})  # a sweep in which the gripper (servo 6) never moves; the stops 1024, 3072
s = Sweep()
s.still = {6}
d = arm(s, robot_id="my_arm")
said = calibrate(d, s, ["c"])
g = d.calibration.joints["gripper"]
print(f"still gripper: calibrate(): {said}; the driver's gripper range now {g.range_min}..{g.range_max}; servos hold {s._homing(1)}")
print(f"still gripper: the same session's read(): {read(d)}; {upper(d, s)}")
d2 = arm(s, robot_id="my_arm")
print(f"still gripper: next connect loads {short(d2.calibration_source)}; {upper(d2, s)}")
shutil.rmtree(root)

dev cc15d9a7
id: ['so_follower/my_arm.json', 'so_follower/other_arm.json'] -> Robot(id='my_arm') loads None; shoulder_pan=1.00: goal 2700; warnings []
id: ['so_follower/other_arm.json'] -> Robot(id='my_arm') loads so_follower/other_arm.json; shoulder_pan=1.00: goal 2681; warnings []
id: ['so_follower/my_awesome_follower_arm.json'] -> Robot(id='left') loads so_follower/my_awesome_follower_arm.json; shoulder_pan=-1.92: goal 1024; warnings []
save: session 1, id 'my_arm', loads so_follower/my_arm.json; lower limit: goal 1024, encoder 1024
save: calibrate(): homing 301, saved to so101_follower/so101_follower.json; servos hold 301; files ['so101_follower/so101_follower.json', 'so_follower/my_arm.json']
save: session 2 loads so_follower/my_arm.json (homing 0); lower limit: goal 1024, encoder 1325
two arms: B, no id, loads so_follower/arm_a.json; B's calibrate(): homing 301, saved to so101_follower/so101_follower.json; files ['so101_follower/so101_follower.json', 'so_follower/arm_a.json']
two arms: A, no id, loads so_follower/arm_a.json; lower limit: goal 1024, encoder 1024
two arms: A, id 'arm_a', loads so_follower/arm_a.json; lower limit: goal 1024, encoder 1024
two arms: B again, no id, loads so_follower/arm_a.json; lower limit: goal 1024, encoder 1325
guess: no id, loads so_follower/my_arm.json; calibrate(): homing 301, saved to so101_follower/so101_follower.json; servos hold 301
guess: then id 'my_arm', calibrate(): homing 301, saved to so101_follower/so101_follower.json; files ['so101_follower/so101_follower.json', 'so_follower/my_arm.json']
guess: next connect, id, loads so_follower/my_arm.json; lower limit: goal 1024, encoder 1325
guess: next connect, no id, loads so_follower/my_arm.json; lower limit: goal 1024, encoder 1325
ask ['']: returned after 2 prompt(s); before the first answer: torque frames [0], homing writes 6; servos hold 301, the file 120
ask ['^C']: Ctrl-C after 1 prompt(s); before the first answer: torque frames [0], homing writes 6; servos hold 0, the file 120
ask ['c', '^C']: Ctrl-C after 2 prompt(s); before the first answer: torque frames [0], homing writes 6; servos hold 301, the file 120
wrist_roll: sweep, wrist_roll still, as LeRobot asks: calibrate(): homing 301, saved to so101_follower/so101_follower.json; wrist_roll range 2047..2047; read(): ZeroDivisionError: float division by zero
wrist_roll: sweep, every joint moves: calibrate(): homing 301, saved to so101_follower/so101_follower.json; wrist_roll range 1847..2247; read(): finite: True
still gripper: calibrate(): homing 301, saved to so101_follower/so101_follower.json; the driver's gripper range now 2047..2047; servos hold 301
still gripper: the same session's read(): ZeroDivisionError: float division by zero; upper limit: goal 2247, encoder 2548
still gripper: next connect loads so_follower/my_arm.json; upper limit: goal 3072, encoder 3373
this PR
id: ['so_follower/my_arm.json', 'so_follower/other_arm.json'] -> Robot(id='my_arm') loads so_follower/my_arm.json; shoulder_pan=1.00: goal 2581; warnings []
id: ['so_follower/other_arm.json'] -> Robot(id='my_arm') loads None; shoulder_pan=1.00: goal 2700; warnings ["so101_follower: no calibration file for id 'my_arm', only ['<root>/robots/so_follower/other_arm.json']; joints map raw full-turn counts. Pass calibration=<path>, or the id LeRobot calibrated this arm with"]
id: ['so_follower/my_awesome_follower_arm.json'] -> Robot(id='left') loads None; shoulder_pan=-1.92: goal 796; warnings ["so101_follower: no calibration file for id 'left', only ['<root>/robots/so_follower/my_awesome_follower_arm.json']; joints map raw full-turn counts. Pass calibration=<path>, or the id LeRobot calibrated this arm with"]
save: session 1, id 'my_arm', loads so_follower/my_arm.json; lower limit: goal 1024, encoder 1024
save: calibrate(): homing 301, saved to so_follower/my_arm.json; servos hold 301; files ['so_follower/my_arm.json']
save: session 2 loads so_follower/my_arm.json (homing 301); lower limit: goal 1847, encoder 2148
two arms: B, no id, loads so_follower/arm_a.json; B's calibrate(): RuntimeError: with no id, <root>/robots/so_follower/arm_a.json may be another arm's: pass id= or calibration=; write frames sent 0; files ['so_follower/arm_a.json']
two arms: A, no id, loads so_follower/arm_a.json; lower limit: goal 1024, encoder 1024
two arms: A, id 'arm_a', loads so_follower/arm_a.json; lower limit: goal 1024, encoder 1024
two arms: B again, no id, loads so_follower/arm_a.json; lower limit: goal 1024, encoder 1024
guess: no id, loads so_follower/my_arm.json; calibrate(): RuntimeError: with no id, <root>/robots/so_follower/my_arm.json may be another arm's: pass id= or calibration=; write frames sent 0; servos hold 0
guess: then id 'my_arm', calibrate(): homing 301, saved to so_follower/my_arm.json; files ['so_follower/my_arm.json']
guess: next connect, id, loads so_follower/my_arm.json; lower limit: goal 1847, encoder 2148
guess: next connect, no id, loads so_follower/my_arm.json; lower limit: goal 1847, encoder 2148
ask ['']: returned after 1 prompt(s); before the first answer: torque frames [], homing writes 0; servos hold 120, the file 120
ask ['^C']: Ctrl-C after 1 prompt(s); before the first answer: torque frames [], homing writes 0; servos hold 120, the file 120
ask ['c', '^C']: Ctrl-C after 2 prompt(s); before the first answer: torque frames [], homing writes 0; servos hold 120, the file 120
wrist_roll: sweep, wrist_roll still, as LeRobot asks: calibrate(): homing 301, saved to so101_follower/my_arm.json; wrist_roll range 0..4095; read(): finite: True
wrist_roll: sweep, every joint moves: calibrate(): homing 301, saved to so101_follower/my_arm.json; wrist_roll range 0..4095; read(): finite: True
still gripper: calibrate(): ValueError: so101: the sweep recorded no range for ['gripper']: nothing saved, and the servos have their homing offsets back. Run calibrate() again and move each of them through its full range; write frames sent 55; the driver's gripper range now 1024..3072; servos hold 0
still gripper: the same session's read(): finite: True; upper limit: goal 3072, encoder 3072
still gripper: next connect loads so_follower/my_arm.json; upper limit: goal 3072, encoder 3072

This PR's question reads so101 has a calibration (<root>/robots/so_follower/my_arm.json). Enter keeps it, c re-records (torque goes off). In the still gripper lines my_arm.json's stops are encoder 1024 and 3072:
dev's next connect maps that file onto the new offsets (3373); this PR's refusal puts the old offsets back
(servos hold 0), and both sessions send the upper limit to 3072.

In the Robot(id='left') lines LeRobot's tutorial file, my_awesome_follower_arm.json, is the only one there,
with shoulder_pan's stops at 1024 and 3072 (homing 0). Dev never passes the id, so it loads that file and sends
the lower limit, -1.92 rad, as goal 1024. This PR's id names left.json, which is not there: it loads none, warns,
and maps the full turn (2048 is 0 rad), so the same limit goes out as goal 796, 228 counts (20°) past that file's
stop. The warning names the file and asks for calibration=<path> or the id LeRobot calibrated the arm with. The
fake bus enforces no position limit: what a servo holding LeRobot's Min_Position_Limit (its write_calibration(),
feetech.py:268-273) does with goal 796 was not measured.

A sweep with no reading, e_no_sweep.py:

# From the repo root: python e_no_sweep.py. calibrate(sweep_seconds=0) on the suite's FakeSerial (no file loaded,
# so no question on either tree): what it records, the homing offset servo 1 then holds (0 before), and the goals
# sent at shoulder_pan's two limits afterwards.
import os, shutil, sys, tempfile
sys.path[:0] = [".", "tests"]
os.environ["HF_LEROBOT_CALIBRATION"] = root = tempfile.mkdtemp()
import numpy as np
from test_drivers import FakeSerial
from strands_robots import Description
from strands_robots.robot.drivers import feetech as ft

s = FakeSerial()
d = ft.FeetechDriver(Description.load("so101"), port="/dev/fake", bus=ft.FeetechBus("/dev/fake", serial=s), robot_id="my_arm")
try:
    cal = d.calibrate(interactive=True, prompt=lambda msg: "", sweep_seconds=0)
    j = cal.joints["shoulder_pan"]
    print(f"calibrate(sweep_seconds=0): shoulder_pan range_min {j.range_min}, range_max {j.range_max}; servos hold {s._homing(1)}")
    for k, rad in enumerate(d.description.limits["shoulder_pan"]):
        d.write(np.array([rad, 0, 0, 0, 0, 0]))
        print(f"  shoulder_pan to its {('lower', 'upper')[k]} limit: goal {int.from_bytes(s.regs[1][ft.REG_GOAL_POSITION : ft.REG_GOAL_POSITION + 2], 'little')}")
except ValueError as e:
    print(f"calibrate(sweep_seconds=0): ValueError: {e}; servos hold {s._homing(1)}")
shutil.rmtree(root)

dev cc15d9a7
calibrate(sweep_seconds=0): shoulder_pan range_min 4096, range_max 0; servos hold 1
  shoulder_pan to its lower limit: goal 4096
  shoulder_pan to its upper limit: goal 0
this PR
calibrate(sweep_seconds=0): ValueError: so101: the sweep recorded no range for ['shoulder_pan', 'shoulder_lift', 'elbow_flex', 'wrist_flex', 'gripper']: nothing saved, and the servos have their homing offsets back. Run calibrate() again and move each of them through its full range; servos hold 0

A Ctrl-C after the middle pose, at the sweep's prompt and inside the sweep, e_sweep.py (python e_sweep.py on
dev, which asks no question; python e_sweep.py c here):

# From the repo root: python e_sweep.py [c] ("c" answers this PR's question; dev asks none). A Ctrl-C at the sweep
# prompt, then one on the sweep's 5th bus read, each after the middle pose. FakeSerial; a temp HF_LEROBOT_CALIBRATION.
import json, os, shutil, sys, tempfile
sys.path[:0] = [".", "tests"]
os.environ["HF_LEROBOT_CALIBRATION"] = root = tempfile.mkdtemp()
import numpy as np
from test_drivers import CAL, FakeSerial
from strands_robots import Description
from strands_robots.robot.drivers import feetech as ft

path = os.path.join(root, "robots", "so_follower", "my_arm.json")
os.makedirs(os.path.dirname(path))

class Sweep(FakeSerial):  # Ctrl-C on the sweep's n-th bus read
    at = reads = 0

    def write(self, data):
        if self.at and data[4] == ft.SYNC_READ:
            self.reads += 1
            if self.reads == self.at:
                raise KeyboardInterrupt
        super().write(data)

def arm(s):
    return ft.FeetechDriver(Description.load("so101"), port="/dev/fake", bus=ft.FeetechBus("/dev/fake", serial=s), robot_id="my_arm")

for where in ("the sweep prompt", "the sweep's 5th bus read"):
    json.dump(CAL, open(path, "w"))
    s, answers = Sweep(), iter(sys.argv[1:])

    def prompt(msg):
        if "MIDDLE" in msg:
            s.actual.update(dict.fromkeys(s.actual, 2348))  # the operator's middle pose
            return ""
        if "full range" in msg:
            if where == "the sweep prompt":
                raise KeyboardInterrupt
            s.at = 5
            return ""
        return next(answers)

    try:
        arm(s).calibrate(interactive=True, prompt=prompt, sweep_seconds=5)
    except KeyboardInterrupt:
        pass
    s.at = 0
    d = arm(s)  # the next connect
    d.write(np.array([d.description.limits["shoulder_pan"][0], 0, 0, 0, 0, 0]))
    goal = int.from_bytes(s.regs[1][ft.REG_GOAL_POSITION : ft.REG_GOAL_POSITION + 2], "little")
    print(f"Ctrl-C at {where}: servos hold homing {s._homing(1)}, the file {json.load(open(path))['shoulder_pan']['homing_offset']}; "
          f"next connect: lower limit goal {goal}, encoder {goal + s._homing(1)}")
shutil.rmtree(root)

dev cc15d9a7
Ctrl-C at the sweep prompt: servos hold homing 301, the file 0; next connect: lower limit goal 1024, encoder 1325
Ctrl-C at the sweep's 5th bus read: servos hold homing 301, the file 0; next connect: lower limit goal 1024, encoder 1325
this PR
Ctrl-C at the sweep prompt: servos hold homing 301, the file 0; next connect: lower limit goal 1024, encoder 1325
Ctrl-C at the sweep's 5th bus read: servos hold homing 301, the file 0; next connect: lower limit goal 1024, encoder 1325

A save that fails after a full sweep (my_arm.json made read-only), python k_failed_save.py c '' '':

# From a root holding strands_robots/ and tests/ (with SweepSerial): python k_failed_save.py <answers...>.
# so_follower/my_arm.json (homing 0, stops 1024..3072) loaded for id "my_arm" and made read-only; a full sweep,
# then the save fails. After it: the servos' offset, and shoulder_pan's upper limit in the same session and at
# the next connect.
import json, os, shutil, stat, sys, tempfile
sys.path[:0] = [".", "tests"]
os.environ["HF_LEROBOT_CALIBRATION"] = root = tempfile.mkdtemp()
import numpy as np
from test_drivers import CAL, SweepSerial
from strands_robots import Description
from strands_robots.robot.drivers import feetech as ft
p = os.path.join(root, "robots", "so_follower", "my_arm.json")
os.makedirs(os.path.dirname(p)); json.dump(CAL, open(p, "w")); os.chmod(p, stat.S_IRUSR)
UP = Description.load("so101").limits["shoulder_pan"][1]
arm = lambda s: ft.FeetechDriver(Description.load("so101"), port="/dev/fake", bus=ft.FeetechBus("/dev/fake", serial=s), robot_id="my_arm")
def upper(d, s):
    d.write(np.array([UP, 0, 0, 0, 0, 0]))
    return f"goal {int.from_bytes(s.regs[1][ft.REG_GOAL_POSITION : ft.REG_GOAL_POSITION + 2], 'little')} -> encoder {s.actual[1]}"
s = SweepSerial()
d = arm(s)
s.actual.update(dict.fromkeys(s.actual, 2348))
it = iter(sys.argv[1:])
try:
    d.calibrate(interactive=True, prompt=lambda msg: next(it), sweep_seconds=0.1)
    print(f"calibrate(): returned; servos hold homing {s._homing(1)}")
except OSError as e:
    print(f"calibrate(): {type(e).__name__}; servos hold homing {s._homing(1)}; the file's homing {json.load(open(p))['shoulder_pan']['homing_offset']}")
s.still = set(s.actual)
print(f"same session: shoulder_pan upper limit {upper(d, s)}")
print(f"next connect: shoulder_pan upper limit {upper(arm(s), s)} (my_arm.json's stop: 3072)")
os.chmod(p, stat.S_IRUSR | stat.S_IWUSR); shutil.rmtree(root)

this PR
calibrate(): PermissionError; servos hold homing 301; the file's homing 0
same session: shoulder_pan upper limit goal 2247 -> encoder 2548
next connect: shoulder_pan upper limit goal 3072 -> encoder 3373 (my_arm.json's stop: 3072)

LeRobot at the pinned 53feaef3, a code reading of robots/so_follower/so_follower.py, motors/feetech/feetech.py
and motors/motors_bus.py: calibrate() asks first when a calibration exists (so_follower.py:139-147), and
Enter writes the kept one to the servos (:146, write_calibration(): Homing_Offset, Min_Position_Limit and
Max_Position_Limit, feetech.py:268-273); homing is set only after the middle-pose Enter, for every motor
(:156-157, set_half_turn_homings(), which first calls reset_calibration(), motors_bus.py:791; that empties
the bus calibration, :773, so after a refused sweep every normalized read or write raises "has no calibration
registered", :855-856 and :884-885); wrist_roll is left out of the sweep and recorded as 0..4095
(so_follower.py:160-168);
record_ranges_of_motion() raises ValueError("Some motors have the same min and max values: ...") for the
motors it sweeps (motors_bus.py:848-850); and connect() runs calibrate() again (so_follower.py:122-126)
when is_calibrated is false, that is when the servos' offsets or ranges differ from the file's, or no file
loaded (feetech.py:228-245).

Acceptance check 9 on the fake bus, zsh acceptance_calibrate.sh <root> <scratch>, which writes a LeRobot-format
robots/so_follower/my_arm.json and runs the calibrate test with this plugin beside it:

#!/bin/zsh
# Acceptance check 9's calibrate test on the fake bus, with a LeRobot-style so_follower/my_arm.json on disk.
# $1 = a tree holding strands_robots/, tests/test_drivers.py and tests_integ/; $2 = scratch dir (removed after)
set -e
root=$1; scratch=$2
rm -rf $scratch; mkdir -p $scratch/hf/robots/so_follower
python3 -I -c "
import json
names = ('shoulder_pan', 'shoulder_lift', 'elbow_flex', 'wrist_flex', 'wrist_roll', 'gripper')
cal = {n: {'id': i + 1, 'drive_mode': int(n == 'wrist_roll'), 'homing_offset': 0, 'range_min': 1024, 'range_max': 3072} for i, n in enumerate(names)}
json.dump(cal, open('$scratch/hf/robots/so_follower/my_arm.json', 'w'), indent=4)"
touch $scratch/port
cd $root
HF_LEROBOT_CALIBRATION=$scratch/hf STRANDS_SO101_PORT=$scratch/port PYTHONPATH=$root:$root/tests:${0:A:h} \
  nice -n 10 pytest -q -p no:cacheprovider --timeout=300 -p fakebus_plugin -rs tests_integ/acceptance/test_feetech_so101.py -k calibrate 2>&1 | tail -4
rm -rf $scratch

"""pytest plugin: every FeetechBus the driver opens is the suite's FakeSerial (no serial port is opened).

usage: PYTHONPATH=<tree>:<tree>/tests:<this dir> pytest -p fakebus_plugin tests_integ/acceptance
STRANDS_SO101_PORT only has to name an existing plain file (the module's skipif).
"""

import pytest


@pytest.hookimpl(tryfirst=True)
def pytest_configure(config):
    import strands_robots.robot.drivers.feetech.driver as fd
    from test_drivers import FakeSerial

    from strands_robots.robot.drivers import feetech as ft

    fd.FeetechBus = lambda port, *, baud=1_000_000: ft.FeetechBus(port, serial=FakeSerial())

dev cc15d9a7
s                                                                        [100%]
=========================== short test summary info ============================
SKIPPED [1] tests_integ/acceptance/test_feetech_so101.py:108: no LeRobot calibration at <scratch>/hf/robots/so101_follower/so101_follower.json: run lerobot-calibrate for this arm first
1 skipped, 4 deselected in 0.72s
this PR
.                                                                        [100%]
1 passed, 4 deselected in 1.21s

wrist_roll's full turn. LeRobot records wrist_roll as 0..4095 (so_follower.py:167-168), and so does this
PR's calibrate(); the driver maps that range onto the description's limits, ±2.7925 rad. After this PR's
calibrate() with the middle pose at encoder 2348 (homing 301), python k_wrist_roll_map.py:

# From a root holding strands_robots/ and tests/ (with SweepSerial): python k_wrist_roll_map.py. A calibrate() with
# answers c, '', '' over so_follower/my_arm.json (id "my_arm"), middle pose at encoder 2348; then wrist_roll (servo 5)
# to a few angles: the goal sent and the encoder's angle from the middle pose on the suite's fake bus.
import json, math, os, shutil, sys, tempfile
sys.path[:0] = [".", "tests"]
os.environ["HF_LEROBOT_CALIBRATION"] = root = tempfile.mkdtemp()
import numpy as np
from test_drivers import CAL, SweepSerial
from strands_robots import Description
from strands_robots.robot.drivers import feetech as ft
p = os.path.join(root, "robots", "so_follower", "my_arm.json")
os.makedirs(os.path.dirname(p)); json.dump(CAL, open(p, "w"))
s = SweepSerial(); d = ft.FeetechDriver(Description.load("so101"), port="/dev/fake", bus=ft.FeetechBus("/dev/fake", serial=s), robot_id="my_arm")
s.actual.update(dict.fromkeys(s.actual, 2348)); it = iter(["c", "", ""])
cal = d.calibrate(interactive=True, prompt=lambda msg: next(it), sweep_seconds=0.1)
s.still = set(s.actual)
print(f"wrist_roll range {cal.joints['wrist_roll'].range_min}..{cal.joints['wrist_roll'].range_max}, homing {cal.joints['wrist_roll'].homing_offset}")
for r in (1.0, 2.0, 2.4, 2.7925):
    d.write(np.array([0, 0, 0, 0, r, 0]))
    g = int.from_bytes(s.regs[5][ft.REG_GOAL_POSITION:ft.REG_GOAL_POSITION + 2], "little")
    print(f"wrist_roll {r:.4f} rad ({math.degrees(r):.0f} deg): goal {g} ({(g - 2047) * 360 / 4096:+.0f} deg from 2047), encoder {s.actual[5]} ({(s.actual[5] - 2348) * 360 / 4096:+.0f} deg from the middle pose)")
shutil.rmtree(root)

this PR
wrist_roll range 0..4095, homing 301
wrist_roll 1.0000 rad (57 deg): goal 2781 (+65 deg from 2047), encoder 3082 (+65 deg from the middle pose)
wrist_roll 2.0000 rad (115 deg): goal 3514 (+129 deg from 2047), encoder 3815 (+129 deg from the middle pose)
wrist_roll 2.4000 rad (138 deg): goal 3807 (+155 deg from 2047), encoder 12 (-205 deg from the middle pose)
wrist_roll 2.7925 rad (160 deg): goal 4095 (+180 deg from 2047), encoder 300 (-180 deg from the middle pose)

Goal 2781 is 734 counts, 64.5°, from the middle (2047), where the description's angle is 57.3°; at the limit the
goal is 4095, 180° from the middle, where the description says 160°. At 2.4 rad the fake bus, which models
Present = Actual - Homing mod 4096, puts the encoder at 12, -205° from the middle pose, the other way around; what a
real STS3215 does with a goal past 4095 minus its offset was not measured. A file LeRobot made maps the same way on
dev and on this PR, and the twin shows the description's angle: python k_wrist_twin.py, a real
Robot(id="my_arm") with its twin over a LeRobot-shaped so_follower/my_arm.json:

# From a root holding strands_robots/ and tests/: python k_wrist_twin.py. A LeRobot-made so_follower/my_arm.json
# (drive_mode 0, homing 0, wrist_roll 0..4095 as LeRobot's so_follower.py:167-168 records it, the other joints
# 1024..3072) is the only file there; a real Robot("so101", id="my_arm") on the suite's FakeSerial, with its twin.
# wrist_roll to 1.0 rad and to its upper limit: the goal sent, the servo's angle from the middle (count 2047), what
# the real robot reports and where its twin's wrist_roll is placed.
import json, math, os, shutil, sys, tempfile
sys.path[:0] = [".", "tests"]
os.environ["HF_LEROBOT_CALIBRATION"] = root = tempfile.mkdtemp()
from test_drivers import CAL, FakeSerial
from strands_robots import Description, Robot
from strands_robots.robot.drivers import feetech as ft
from strands_robots.robot.drivers.feetech import driver as ftd

cal = {k: dict(v, drive_mode=0) for k, v in CAL.items()}
cal["wrist_roll"].update(range_min=0, range_max=4095)
p = os.path.join(root, "robots", "so_follower", "my_arm.json")
os.makedirs(os.path.dirname(p))
json.dump(cal, open(p, "w"))
s = FakeSerial()
ftd.FeetechBus = lambda port, baud: ft.FeetechBus(port, serial=s)
real = Robot("so101", port="/dev/fake", id="my_arm")
k = real.body.names.index("wrist_roll")
up = Description.load("so101").limits["wrist_roll"][1]
src = os.path.relpath(real.body.calibration_source, os.path.join(root, "robots"))
print(f"loads {src}; wrist_roll range {real.body.calibration.joints['wrist_roll'].range_min}..{real.body.calibration.joints['wrist_roll'].range_max}; limits +-{up:.4f} rad")
for r in (1.0, up):
    obs = real.act({"wrist_roll": r})
    goal = int.from_bytes(s.regs[k + 1][ft.REG_GOAL_POSITION : ft.REG_GOAL_POSITION + 2], "little")
    tw = real.twin.observe(images=False).joints
    t = float(tw.positions[tw.names.index("wrist_roll")])
    print(
        f"wrist_roll {r:.4f} rad ({math.degrees(r):.1f} deg): goal {goal}, servo {(goal - 2047) * 360 / 4096:+.1f} deg "
        f"from the middle; real reports {math.degrees(obs.joints.positions[k]):.1f} deg; twin placed at {math.degrees(t):.1f} deg"
    )
real.close()
shutil.rmtree(root)

dev cc15d9a7
loads so_follower/my_arm.json; wrist_roll range 0..4095; limits +-2.7925 rad
wrist_roll 1.0000 rad (57.3 deg): goal 2781, servo +64.5 deg from the middle; real reports 57.3 deg; twin placed at 57.3 deg
wrist_roll 2.7925 rad (160.0 deg): goal 4095, servo +180.0 deg from the middle; real reports 160.0 deg; twin placed at 160.0 deg
this PR
loads so_follower/my_arm.json; wrist_roll range 0..4095; limits +-2.7925 rad
wrist_roll 1.0000 rad (57.3 deg): goal 2781, servo +64.5 deg from the middle; real reports 57.3 deg; twin placed at 57.3 deg
wrist_roll 2.7925 rad (160.0 deg): goal 4095, servo +180.0 deg from the middle; real reports 160.0 deg; twin placed at 160.0 deg

Dev's own calibrate() recorded the swept range instead (2047..2047 or 1847..2247 in the wrist_roll lines
above).

Rates and the driver's write. e_rates_write.py:

# From the repo root: python e_rates_write.py. A hardware Robot on the suite's FakeSerial.
import math, sys, time
sys.path[:0] = [".", "tests"]
import numpy as np
from test_drivers import make_driver, writes
from test_operator_gate import goal_writes
from strands_robots import Robot
from strands_robots.robot.drivers import feetech as ft

class Loads:  # attach() stands for loading a checkpoint
    attached = False
    def attach(self, robot): self.attached = True
    def act(self, obs, *, instruction=None): return {"shoulder_pan": 0.1}
    def reset(self): pass

for hz in (50.0, math.inf, math.nan, 1e6):
    d, s = make_driver(); real = Robot("so101", driver=d, twin=False); pol = Loads(); t = time.perf_counter()
    try: out = f"{real.run(pol, hz=hz, steps=50).steps} steps"
    except ValueError as e: out = f"ValueError: {e}"
    print(f"run(hz={hz}, steps=50): {out}; attached {pol.attached}; goal/torque frames {len(goal_writes(s))} in {time.perf_counter() - t:.3f} s")
    real.close()
for hz in (50.0, math.inf, math.nan, 1e6):
    d, s = make_driver(); real = Robot("so101", driver=d, twin=False); n0 = len(s.frames)
    try: real.subscribe("state", lambda p: None, hz=hz); out = "accepted"
    except ValueError as e: out = f"ValueError: {e}"
    time.sleep(0.2)
    print(f"subscribe('state', hz={hz}): {out}; bus reads in 0.2 s: {sum(f[4] == ft.SYNC_READ for f in s.frames[n0:])}")
    real.close()
d, s = make_driver()
try: d.write(np.array([math.nan, 0, 0, 0, 0, 0]))
except ValueError as e: print(f"FeetechDriver.write([nan, 0, 0, 0, 0, 0]): ValueError: {e}; frames sent {len(writes(s))}; torque {d.extras()['torque']}")

dev cc15d9a7
run(hz=50.0, steps=50): 50 steps; attached True; goal/torque frames 51 in 1.004 s
run(hz=inf, steps=50): 50 steps; attached True; goal/torque frames 51 in 0.007 s
run(hz=nan, steps=50): 50 steps; attached True; goal/torque frames 51 in 0.007 s
run(hz=1000000.0, steps=50): 50 steps; attached True; goal/torque frames 51 in 0.007 s
subscribe('state', hz=50.0): accepted; bus reads in 0.2 s: 10
subscribe('state', hz=inf): accepted; bus reads in 0.2 s: 5382
subscribe('state', hz=nan): accepted; bus reads in 0.2 s: 5187
subscribe('state', hz=1000000.0): accepted; bus reads in 0.2 s: 4881
FeetechDriver.write([nan, 0, 0, 0, 0, 0]): ValueError: so101.shoulder_pan: non-finite goal nan; frames sent 1; torque True
this PR
run(hz=50.0, steps=50): 50 steps; attached True; goal/torque frames 51 in 1.027 s
run(hz=inf, steps=50): ValueError: hz must be a finite number > 0, got inf; attached False; goal/torque frames 0 in 0.000 s
run(hz=nan, steps=50): ValueError: hz must be a finite number > 0, got nan; attached False; goal/torque frames 0 in 0.000 s
run(hz=1000000.0, steps=50): 50 steps; attached True; goal/torque frames 51 in 0.009 s
subscribe('state', hz=50.0): accepted; bus reads in 0.2 s: 11
subscribe('state', hz=inf): ValueError: hz must be a finite number > 0, got inf; bus reads in 0.2 s: 0
subscribe('state', hz=nan): ValueError: hz must be a finite number > 0, got nan; bus reads in 0.2 s: 0
subscribe('state', hz=1000000.0): accepted; bus reads in 0.2 s: 4663
FeetechDriver.write([nan, 0, 0, 0, 0, 0]): ValueError: so101.shoulder_pan: non-finite goal nan; frames sent 0; torque False

python -c "import json; print(json.loads('{\"hz\": Infinity, \"h2\": NaN}'))" prints {'hz': inf, 'h2': nan}.
Simulation.run, whose lock-step loop this PR does not touch, python lockstep_hz.py <root>:

import math
import sys

sys.path.insert(0, sys.argv[1])
from strands_robots import Robot, Simulation  # noqa: E402

for hz in (math.inf, math.nan, 0.0, -5.0):
    sim = Simulation()
    arm = Robot("so101", sim=sim)
    t0 = sim.time
    try:
        res = sim.run({arm: lambda o: o.joints.positions}, hz=hz, steps=10)[arm.id]
        out = f"ran {res.steps} steps, hz_target {res.hz_target}"
    except Exception as e:  # noqa: BLE001
        out = f"{type(e).__name__}: {e}"
    print(f"Simulation.run(hz={hz}, steps=10): {out}; world time {t0:.3f} -> {sim.time:.3f} s")
    sim.close()

dev cc15d9a7
Simulation.run(hz=inf, steps=10): ZeroDivisionError: float division by zero; world time 0.000 -> 0.020 s
Simulation.run(hz=nan, steps=10): ValueError: cannot convert float NaN to integer; world time 0.000 -> 0.000 s
Simulation.run(hz=0.0, steps=10): ZeroDivisionError: float division by zero; world time 0.000 -> 0.000 s
Simulation.run(hz=-5.0, steps=10): ran 10 steps, hz_target -5.0; world time 0.000 -> 0.020 s
this PR
Simulation.run(hz=inf, steps=10): ZeroDivisionError: float division by zero; world time 0.000 -> 0.020 s
Simulation.run(hz=nan, steps=10): ValueError: cannot convert float NaN to integer; world time 0.000 -> 0.000 s
Simulation.run(hz=0.0, steps=10): ZeroDivisionError: float division by zero; world time 0.000 -> 0.000 s
Simulation.run(hz=-5.0, steps=10): ran 10 steps, hz_target -5.0; world time 0.000 -> 0.020 s

Tests and checks (this PR on dev cc15d9a).

• Red first: pytest -rf tests/test_render_thread.py tests/test_feetech_calibration.py tests/test_non_finite.py tests/test_drivers.py::test_calibrate_writes_lerobot_json, this PR's tests/ against dev's strands_robots/:
  25 failed, 10 passed, each failure for its reason: the GLFW render went to strands-gl; an id loaded None (2)
  or another arm's file (2); the save went to so101_follower/so101_follower.json (4); a guessed file was
  recorded instead of refused (DID NOT RAISE RuntimeError); dev re-recorded instead of asking; homing ended
  [0]*6, [1]*6 and [0]*6 instead of 120; wrist_roll recorded 2047..2047 and 1847..2247 instead of
  0..4095; DID NOT RAISE ValueError (2) and (4, the rates); the Torque_Enable SYNC_WRITE went out (3). The 10
  that pass: the existing render test, five non-GLFW routing cases, the disable child, the no-id and
  nothing-on-disk cases, and test_calibrate_writes_lerobot_json, which now sweeps 200 counts each way. This PR:
  35 passed. On this PR's package without the offset write-back, both refusal cases fail with
  assert [1, 1, 1, 1, 1, 1] == [120, 120, 120, 120, 120, 120].
• Each commit passes its own tests with test_layout, test_drivers, test_run, test_device,
  test_operator_gate, test_render_thread, test_public_surface and test_device_safety (132, 132, 138, 143,
  147, 149, 151, 155 and 158 passed).
• ruff check and ruff format --check (strands_robots tests tests_integ): All checks passed!, 190 files already formatted; mypy strands_robots: Success: no issues found in 123 source files; lint-imports:
  Contracts: 8 kept, 0 broken.
• pytest -q -p no:cacheprovider --timeout=300 from the root, MUJOCO_GL unset: 678 passed, 32 skipped in 166 s;
  every skip is an environment one (LeRobot not in this venv 10, Isaac 16, Newton 5, the opt-in live model 1).
• The LeRobot set (tests/policy, test_policy_factory, test_units_lerobot_modes, test_units_lerobot_calibrated,
  in the LeRobot venv): 34 passed. tests/recording there: 2 failed, 30 passed on dev and on this PR, the same two
  (test_a_top_level_script_records_two_cameras, test_a_second_run_in_a_new_process_resumes_the_same_directory:
  assert -11 == 0, their child process ends on signal 11).
• The changelog fragment, checked before this PR had a number as 9999-calibration-recorded-as-lerobot-records-it.md
  with python scripts/assemble_changelog.py --check --fragment-dir <a dir holding only it>: one problem,
  9999 is a placeholder, none in its heading or body; on dev itself --check fails on fix(v1): a faulted run puts the body in its declared on_disconnect state #4793's 0000- fragment
  (0 is a placeholder).
• Files: feetech/driver.py 231 → 239 lines, drivers/calibration.py 59 → 88, drivers/driver.py 103 → 107,
  _gl.py 68 → 78; robot.py (248), run/loop.py (202) and device/events.py (93) keep theirs. Package
  +90 / -39, tests +335 / -8 (with tests_integ/), docs +3 / -3.
• git merge-tree --write-tree of this PR with each open head at 2026-10-18 21:03Z, then tests/test_layout.py on
  the merged tree (git archive): clean, and 4 passed, with fix(v1): while the e-stop is latched, a faulted run, a watchdog lapse and hold() write nothing to the body #4794 fe59b12, fix(v1): a corrupted feetech status packet is read again, not the end of a run or an e-stop's hold #4795 0d37932, fix(v1): a tag on dev publishes 1.0.0rc1, and only the version the package reports #4796 2805bfa, fix(v1): one read and one write per tick, no burst after a stall, one clock, one step #4797
  06e97cf, fix(v1): a wrist camera, per-body randomization, Perturb, one rebuild per edit block #4790 b4b0da9, feat(v1): AWS IoT Core natively: shadows, rules, X.509 and claim, an rpc path per link #4784 73f8102, fix(v1): an agent's call reaches the robot it names, and its run is the robot's one task #4798 b72cb68, fix(v1): a failed on_disconnect is retried, and the watchdog thread survives it #4799 1e0a3a3 and fix(v1): a twin never pushes a simulated arm or mirrors a NaN or huge reading; close() waits for the step in progress #4800 14b2bb1. No strands_robots
  file goes over 250 lines; feetech/driver.py is 250 merged with fix(v1): a corrupted feetech status packet is read again, not the end of a run or an e-stop's hold #4795, else 239. On those nine trees test_drivers,
  test_feetech_calibration, test_non_finite, test_device_safety, test_operator_gate, test_render_thread,
  test_run and test_device give 153, 152, 149, 149, 149, 149, 150, 164 and 149 passed, 149 on this PR alone and
  156 merged with fix(v1): while the e-stop is latched, a faulted run, a watchdog lapse and hold() write nothing to the body #4794, fix(v1): a corrupted feetech status packet is read again, not the end of a run or an e-stop's hold #4795 and fix(v1): a tag on dev publishes 1.0.0rc1, and only the version the package reports #4796 in sequence (feetech/driver.py 250 there too). Once, on an earlier
  version of this branch at a load average near 66, one test failed on that three-way tree, not captured; that
  failure did not recur.
• v1 part 10: the world in a browser tab #4779 2101a4e merges with dev but conflicts with this PR: its _gl.py rewrites on_gl_thread around a
  _GLThread, against this PR's GLFW change (2 hunks), plus 1 hunk in test_render_thread.py; v1: the acceptance suite, the 1.0 definition #4780 6a87744 and
  v1 part 12: the docs #4781 f70a53a conflict in the same two files, v1 part 12: the docs #4781 also in docs/hardware.md and docs/simulation.md (1 each).

Refs #3818

[yinsong1986]

Summary

Four fixes to the v1 Feetech/run surface, each with the fault reproduced on a fake bus first. Robot(id=) now reaches FeetechDriver as robot_id (via make_driver, only for a driver class whose signature takes it), so it names so_follower/<id>.json and never loads another arm's file; with an id and no file of its own it loads none and warns naming the files present. calibrate() saves over the file it loaded (else <type>/<id>.json), refuses with save=True to record over or beside a file it only guessed (no id, the one *.json in the directory), asks before torque goes off when a calibration is loaded, zeroes homing only after the middle pose is confirmed, gives wrist_roll the full turn as LeRobot does, and refuses a sweep that leaves a joint with lo >= hi - restoring the servos' prior homing offsets and leaving the loaded calibration in place, where dev wrote a 2047..2047 range that made read() divide by zero. run(hz=) and subscribe("state", hz=) reject inf/nan with not 0 < hz < inf, and FeetechDriver.write() builds the goal words before enabling torque so a NaN or wrong-length target leaves torque as it was. on_gl_thread runs inline when MUJOCO_GL=glfw on Darwin, which restores the pre-#4789 behaviour for the one platform where the dedicated GL thread trapped. Public signatures are only widened (make_driver(robot_id=)), the on-disk file format is unchanged, and the one behaviour change that can bite an existing caller (id= now selects the calibration file) is surfaced by a warning that names the fix rather than silently.

What's good

• Every refusal is ordered before the side effect it guards: the guessed-file check precedes torque(False), the hz check precedes bind(), the NaN check precedes Torque_Enable, and the homing read-back happens before the first homing write.
• tests/test_feetech_calibration.py asserts on bus frames and files, not driver internals, and the PR body records the red run of the new tests against dev.
• The Darwin-only GLFW branch is pinned by a platform-agnostic routing test plus a MUJOCO_GL=disable child, so the macOS behaviour is graded on Linux CI without a GLFW window.

Verification suggestions

• MUJOCO_GL=egl pytest -q tests/test_feetech_calibration.py tests/test_non_finite.py tests/test_drivers.py tests/test_render_thread.py (76 pass here; the rest of tests/ is green apart from the two pre-existing tests/recording child-process SIGSEGVs the PR body already lists).
• On a Mac with glfw installed, the e_gl.sh probe from the PR body should print exit 0, printed '(48, 64, 3)' for MUJOCO_GL=glfw; dev prints exit 133.
• The author's open question (should a fresh calibrate() save to so_follower/<id>.json as LeRobot 0.6 does, rather than so101_follower/<id>.json) is a maintainer call; the current choice keeps dev's path and is covered by the none-loaded test case.