Leg v2 on the single-leg rig: the plan to a first physical leg (M3)

Written 2026-10-27 by the planner (Fable 5.1) for the Opus implementer. Not committed. Read first: cad/fivebar.py, cad/build_leg.py, cad/leg_studies.py, sim/leg_rig.py, exports/leg/{bom.json,print-plan.json,leg.json,rig-results.json}, exports/leg/fea/summary.json, research/leg-suspension.md (sections 1-8), docs/decisions.yaml D36-D41, docs/milestones.yaml M2-M3, catalog/{hardware,alternates,sourcing,images}.json.

Every price and stock line below says where and when it was read. "Checked today" = 2026-10-27 by this session or by catalog/alternates.json (also 2026-10-27). Sections marked TODO (next session) were cut short by the usage limit.

0. In one paragraph

Build the leg exactly as drawn (no spring, TPU stops kept, wheel fitted but unpowered), print it in PA6-CF after a day of PA6-CF fit coupons (not a PETG leg: PETG shrinkage does not transfer to PA6-CF seats), and hang it on one 8080 extrusion post with two HGR15 profile rails and four HGH15CA blocks behind the hip frame, a 6.35 mm aluminium carriage plate bolted to the frame's six M5 flange inserts, weight plates on two rods for the ballast, printed TPU bumpers under the carriage, and a braced extrusion base with a plywood deck the wheel lands on. Power the RS-04s from the user's FLEXVOLT 60 V pack (48-55 V window, it is the only regen sink that needs no custom electronics), through a 30 A DC fuse and a 12 V-coil DC contactor held in by the pendant loop with a 1 s off-delay; CAN at 1 Mbit/s from a candleLight USB adapter to the laptop, a Feather M4 CAN as the rig's sensor and safety node. The controller is sim/leg_rig.py's own virtual-model controller run at 500 Hz from Python over SocketCAN, first against a MuJoCo backend, then against the motors, with every run logged and overlaid on rig-results.json. Bench tests come before the leg stands: the RS-04's unpowered back-drive torque against speed (decides D39's knee case), the rotor inertia, the TPU sleeve's stiffness, the heat-set insert's torque-tension and pull-out in printed PA6-CF, and the tyre's radial rate. Then stand, squat, jump, drop, and the power cut last, with the bumper set high until the damping is known.

1. Review: what is ready to build, what to simplify, what to defer

1.1 Ready (as of commit 8717f28 plus the uncommitted 07:49 edits to cad/fivebar.py, cad/leg_studies.py)

• Kinematics and the printed parts. exports/leg/leg.json: range 101.5-392.4 mm, no clash at 8 heights x 5 leans, the cable route clears every part, every part fits the 256 mm bed (the hip frame, front link and wheel link turned). Printed mass 2.74 kg, bought 6.39 kg, 9.13 kg per leg. Print plan 182.8 h (PA6-CF 178.5 h, 2.72 kg, $218; TPU 4.3 h).
• Bought parts. exports/leg/bom.json: every line has a McMaster number, $1,121.39 per leg at McMaster prices; catalog/alternates.json (checked today) has a second source for each, and the bearings are much cheaper elsewhere (section 6.1).
• Strength, everyday and landings. exports/leg/fea/summary.json (written 07:22): everyday minimum SF 2.37 (front link E1); landings (R1, the rig's real knee force 753 N at 330 mm, 10 % fore-aft and sideways): whole leg 2.33, upper link 1.41 / 1.64, front link 1.30, wheel link 1.95 (1.36 at the full 1,719 N axle spike), hip frame 1.67, knee 6201s s0 1.39, pins 1.88, eye pressure 1.71, apex 61812 4.59, hub tipping 2.03; front-link buckling SF 11. The output adapters are machined 6061-T6 (D46, 2026-10-27): held where they really sit on the motor (the contact face and the motor's pins), the printed adapter came out at SF 0.86-1.04 across the layers in R1 at the 14.75 kg design mass; the CAD check also found its two face dowels sat inside bolt holes (so there were none), six face inserts broke into the motor-screw counterbores, and the motor screws' heads stood 0.2-1.2 mm into the upper link. The machined adapter fixes all three (exports/leg/cnc/README.md) and is at SF 7.6 in R1.
• The rig physics. sim/leg_rig.py at 13.1 kg (carriage 8.398 kg = frame 3.842 incl. motors and bearings + dummy 4.556; moving parts 4.702 kg): stand-up 12.1 N m peak; squat 12.2 N m; jump at the 60 N m cap 278.9 mm, 3,700 N on the tyre, 2,514 N on the axle, 97.6 N m through a gearbox, 753 N on a knee; 150 mm drop 1,719 N on the axle, 66.5 N m gearbox, 551 N knee, 35.5 N m motor; undamped power cut: 12.2 rad/s, 1,458 N on the knees, 96.8 N m on a stop; with the assumed 5.9 N m s/rad of motor damping: 1.74 rad/s, 192 N, 8.3 N m.

1.2 Known gaps (flag to the main session)

• exports/leg/fea/summary.json predates the last rig run (rig-results.json 07:50): its R3 case still carries 2,609 N on the axle and 2,983 N on the pins (joints 0.69-1.09, upper link R3K 0.75) and is tagged rare, while cad/leg_studies.py now tags it fault (target 1.0) and the current rig gives 1,316 N axle / 1,458 N knee. Re-run cad/leg_studies.py before the build package is final (owner: main session).
• The sim's TPU stop (856 N m/rad, 7.5 mm of travel at the 57.8 mm arm since D53), tyre (7.7 ms / 0.7 contact), rotor inertia (0.0243 kg m^2 reflected) and power-off damping (20 % of shorted phases) are all estimates: that is what the bench tests are for.

1.3 Simplify for the first physical leg (decisions made here)

1. No PETG leg. PETG and PA6-CF shrink differently and PETG prints on a brass nozzle at different flow, so a PETG fit check does not prove a PA6-CF bearing seat, insert hole or dowel fit, and a second 180 h print buys nothing. Instead: PA6-CF fit coupons first (one evening of printing, section 6.2): a 20 mm slice of the hip frame around one motor (10 x M4 lug pattern, two dowel holes, the 61812 seat with its lip), an upper-link hub face (AO face, 8 x M5 inserts, 2 dowels, the spigot recess), a knee eye (two 12 x 18 x 20 sleeves pressed), a knee boss (two 6201 seats and the 27 mm web), an apex eye (61812 seat) and a hub stub (the 60 mm journal with the circlip groove). Every seat diameter gets dialled in on the coupons (LeRobot's builder cracked both bearing seats pressing 15 x 21 bearings into a print; Primo's rule: light fit plus retaining compound, never a heavy interference in PA-CF). Then the structural parts, hip frame last (section 6.2).
2. The wheel is fitted but not driven on the rig. Every rig scenario commands zero wheel torque (d.ctrl[wheel] = 0); the tyre test is static. No BotWheel driver is bought for M3. When the wheel must turn under power (after the drop test passes), the driver is the robot's Flipsky 75100 (14-84 V, $65, in stock at Flipsky CN, catalog 2026-10-25); backup ODrive Pro ($229, 58 V max; S1 sold out). The BotWheel's phase and hall leads are taped along the links for M3; the through-hub cable route is tried later.
3. The stops stay as drawn (TPU 95A sleeves on Ø16 steel pins, the links' radial stop faces: D53). The rig's bottom bumper is set so the carriage lands on the rig at a leg length of 115 mm, above the leg's own stops (101.5 mm), for every test until the power-off damping is measured; only the deliberate collapse test (last) lowers the bumper.
4. No spring (D39, research section 8.7). The knee-to-knee add-on stays on the shelf.
5. Cheaper bearings: 6812-2RS and 6201-2RS from Bearings Direct / VXB (section 6.1), $120 + $69 less per leg.
6. Ballast is standard 1 in weight plates on two rods, not a welded block: the carriage's own plate, blocks and rods are already about 3.3 kg of the 4.56 kg dummy mass, and plates make the half-mass adjustable for the sim's --half-mass sweeps.
7. First motor tests in a printed bench fixture, not in the hip frame, so the bench tests start the day the motors arrive (the hip frame is the last and riskiest print).

1.4 Defer

• The BotWheel driver, the wheel cable through the hub, the knee-to-knee spring, any body parts.
• A measured carriage-height sensor better than a time-of-flight module plus slow-motion video (section 3.4).
• A real-time MCU controller: the first stand is Python on the laptop at 500 Hz; the Feather M4 CAN on the rig is the safety and sensor node now and the place a 1 kHz loop moves to later.

2. The rig

Module frame as in cad/fivebar.py: x forward, y outwards (+y is the linkage and wheel side), z up, y = 0 the motors' output face. Numbers from fivebar.Y and hip_frame(): the frame's flange ends and its six M5 insert bosses are flush on the plane y = -82.3 mm (the robot's centre plane), inserts at (x, z) = (-83, +-70), (0, +-70), (+83, +-70) (fivebar.frame_mounts(), the source of truth), flanges 13 mm thick (z 62-75; 7 mm until the 2026-10-27 review: too weak across the print's layers) spanning x +-95; the motors' rear faces are at y = -80.3 (2 mm inboard of that plane), their 310 mm harnesses exit radially from the O94 rear covers; the stop posts are at (+-104.1, +52.5) and (+-20.6, -25.4) (D53; their TPU sleeves are Ø32, from the frame's face to y 19). Knees reach x +-225 (z +8) at the 101.5 mm crouch and x +-60 (z -149) at 392 mm; the wheel axle is at (0, -L), and (+-103, -282) at +-20 deg of lean at 300 mm; the tyre's mid-plane is y = 104.6 (tyre y 82-127).

2.1 Layout (one post, two rails, behind the hip frame, where the sim already puts the rail)

          side view (looking along +x)                 plan (looking down)
   post 8080 |B|                                        ┌───── base 700 (x) x 900 (y) ─────┐
     rails   |B|  carriage plate 6.35 mm                │         post ▓▓ at y -132..-212   │
   blocks  ▓▓|B|▓ y -89..-117                           │   brace ─╲   ▓▓                    │
             |B|▓──┐ hip frame flange face y -82.3      │           ╲  ▓▓ rails (x = +-20)   │
             |B|▓  │ motors y -80..-25                  │   deck      ▓▓ plate x +-150       │
             |B|▓  │ links y 0..80, tyre y 82..127      │        frame x +-95                │
   bumper ▄▄ |B|   └── wheel E = (0, -L)                │        wheel lands here, x +-110   │
   ───────────────── deck (18 mm plywood on 4040)       └──────────────────────────────────┘

• Post: MISUMI HFS8-8080 (80 x 80, 10 mm slots, two slots per face 40 mm apart, 4.57 kg/m, I about 129 cm^4 per the MISUMI table), 1,200 mm. The two rails bolt to its front face on the slot centres x = +-20 with M4 T-nuts. Why not 2040 V-slot and V-wheels: the carriage must react the wheel force's roll moment about x, F x (104.6 + 132) mm: 3,700 N x 0.237 m = about 880 N m at the jump's push, 410 N m in the 150 mm drop. A V-wheel gantry plate's wheels are 60-80 mm apart and rated tens of kilograms each: it cannot. Profile rail blocks can.
• Rails and blocks: two HGR15 x 1,000 mm rails, four HGH15CA blocks (34 mm wide, 61.4 long, 4 x M4 on 26 x 26, Hiwin C0 about 17 kN), two per rail, 250 mm apart in z (the hip axis midway). The 880 N m couple over 0.25 m is 3.5 kN, shared by the two rails: about 1.8 kN of lateral load per block in y, plus the lean's pitch moment (3,700 N x 0.10 m = 370 N m -> 0.75 kN per block in x): about 2 kN resultant against 17 kN, SF 8. Generic HGR15/HGH15CA sets (section 6.1) are the primary; HGR20/HGH20CA (44 mm wide blocks, C0 40 kN) is the backup if the block spacing has to shrink, on the same slots with M5 T-nuts.
• Post stress and sway: 880 N m on the 8080 at 0.9 m up: 27 MPa bending, 3.8 mm of sway as a bare cantilever (M h^2 / 2EI with I = 1.29e6 mm^4), so add one 4040 diagonal brace in the y-z plane from the post at z = 600 to the base's rear member, 400 mm behind the post (a 1.6 kN strut; sway then well under 1 mm).
• Rail length check: hip axis from 186 mm above the deck (leg 100 mm) to about 790 mm (leg 392 + the 120 N m jump's 308 mm + the wheel radius 86); blocks reach +-155 mm from it: 31 to 945 mm. 1,000 mm rails from the deck level work with 30 mm to spare at the bottom; put the rails' bottom end 20 mm below the deck's top if the post is bolted beside the base frame rather than on it. The sim's rail is 1.1 m.
• Carriage plate: 6061-T6, 6.35 mm (1/4 in), 300 (x) x 320 (z) mm, from SendCutSend (section 6.3). Its front face is the y = -82.3 plane: 6 x O5.5 for M5 x 16 into the frame's inserts (the 7.9 mm inserts take 8 mm of thread); 16 x O4.5 for the four blocks at x = +-20, z = +-125 (26 x 26 patterns); 2 x O8.5 at x = +-120, z = 0 for the ballast rods; a 60 x 15 mm slot at the top edge for the motor harnesses and the leg's cables; a 12 mm hole in a side tab at x = +150, z = 0 for the drop-release pin; four O6.6 at the corners for the top and bottom bumper strikers. Mass 1.65 kg.
• Ballast: two 25 mm aluminium rods 150 mm long pointing back (-y) from the plate at x = +-120, each tapped M8 at the plate end; standard 1 in weight plates (2.5 lb and 5 lb) held by 1 in spring collars. Carriage budget: plate 1.65 + four HGH15CA about 0.7 + rods and collars about 0.8 + screws 0.15 = 3.3 kg; the sim's dummy mass is 4.556 kg, so about 1.3 kg of plates gets the rig to the sim's 8.40 kg carriage; cad/build_rig.py computes the exact figure from the CAD masses and writes it to exports/rig/rig.json (task T2). The half-mass sweep (11-16 kg) is then plates only.
• Bottom stop (fall catch): two printed TPU 95A bumper blocks 60 x 60 x 40 mm, 15 % gyroid, on a PETG bracket clamped in the post's front slots (two M8 T-nuts each), struck by the plate's bottom edge. Set so the carriage lands at a leg length of 115 mm (plate bottom 51 mm above the deck); a 13 mm shim drops it to the leg's own stops (101.5 mm) for the collapse test. Energy: a power cut from 300 mm is 8.4 kg falling 185 mm, 15 J; a 25 mm crush at 600 N average takes it. Printed, replaceable, no bought bumper. Top stop: the same bracket inverted near the rail's top, plus the rails' own end caps.
• Safety tether: a 25 mm webbing loop from the carriage plate's top slot to the post top (through a sewn loop and a carabiner), 150 mm longer than the maximum jump, as the backstop if a block ever leaves a rail; and a 600 mm loop from the wheel link's knee boss to the carriage, so a broken link cannot fly.
• Drop release: a 10 mm steel pin with a lanyard through a PETG bracket clamped to the post at the drop height into the plate's side tab; the carriage (82 N on the pin) is lifted by hand or a rope over the post top, pinned, and the pin pulled.
• Base: 8-series 4040 extrusion rectangle 700 (x) x 900 (y) with one middle cross member, 8-series angle brackets at every joint, an 18 mm plywood deck screwed on top (the wheel lands on it: the jump's 3,700 N down through the tyre and the 880 N m couple through the post's foot are then internal to one stiff frame, so the base cannot tip; the wheel must never run on the bare floor beside the base). The post stands on the rear member, 300 mm from the back edge, with four 8080 brackets and the diagonal brace. Rubber feet or a mat under the frame. Estimated rig mass 25 kg (post 5.5, base 7.5, deck 8, plate and blocks 2.4, brackets 1.5).
• Load plate (stand/squat only): a 400 x 300 x 12 mm plywood pad on four 50 kg half-bridge cells and an HX711 (80 Hz) placed under the wheel for the static tests; removed for jumps and drops (3.7 kN would crush 50 kg cells).
• Cable management: a hanging service loop from an eye at the post top to the carriage (power 2 x 12 AWG, CAN pair, the Feather's USB), zip-tied to the plate's top slot.

2.2 What the rig CAD must check (task T2)

A clearance sweep of the posed leg (fivebar.assembly() at 14 lengths 101.5-392 mm and leans -20/0/+20 deg) against post, rails, blocks, brace, bumpers, bracket, deck and plate (minimum 10 mm); the carriage's travel against the rail length for the 120 N m jump; the block loads at the jump's 3,700 N; the post's bending with and without the brace; the motor harness grommets (vendor STEP, references/vendor/robstride-rs-04/RS04.stp) against the plate and its slot at the frame's lug clocking (7 deg); the masses; the TPU bumper's crush energy.

3. Electronics and power

3.1 The RS-04 as a load

RS-04 (catalog/leg_actuators.json, research/robstride-open-source-2026-10-26.md section 4): rated 48 V, operating 24-60 V with an over-voltage fault at 60 V (the manual; rcdrone's listing says 15-60 V), 40 N m rated on a 345 x 345 mm heat sink, 120 N m peak at 90 A phase current, Kt 2.1 N m/A at the output, 9:1, 200 rpm no load. On the rig the two motors hold about 12 N m each standing (10 W each); the 60 N m jump is about 1 kW mechanical per motor for 0.3 s, so 45-50 A of bus current at 48 V for 0.3 s; landings and squats push energy back into the bus (16 J per 150 mm drop, up to 19 J per squat half-cycle). A bench supply cannot sink that: 16 J into a 2 mF output stage is a 135 V spike, and the RS-04 faults at 60 V. So:

3.2 Power: the FLEXVOLT pack for every test that moves, a bench supply for the bench

• Primary (everything dynamic): DeWalt DCB609 FLEXVOLT 9 Ah in 60 V mode (the user's packs; 15S, 54 V nominal, 60 V full, 3 Ah at 60 V, tool-grade cells). Rule: start every dynamic test between 48 and 55 V (regen at 40 A through the pack's internal resistance lifts the terminals a few volts; the RS-04 trips at 60 V); the laptop logs the motors' VBUS every tick and aborts above 58 V or below 46 V (the pack has no BMS cut-off of its own). Dock adapter with 12 AWG leads for the 60 V mode: Terrafirma Technology on eBay about $16.50, Newegg $23.35, an Etsy seller $16 (search snippets today; none read live; confirm the adapter engages the 60 V tab, as the catalog note says). Charger: the user's DeWalt charger.
• Bench supply (back-drive, spin-down, coupon tests, first static enable): Mean Well LRS-600-48, 48 V 12.5 A, $59.90 at Jameco (68 in stock in the snapshot read today), or the LRS-600N2-48 (200 % peak) $66.10. The bigger RSP-1000-48 (21 A) is $267.95 at Digi-Key via an aggregator / $267.90 at Master Electronics (65 in stock). Never run a drop, jump or squat series on the supply alone.
• Fuse: Littelfuse KLDR030 Class CC time-delay, 30 A, 600 VAC / 300 VDC, $31.70 (536 in stock, Standard Electric Supply, read today) in a Class CC holder (Littelfuse LPSC/LPSM class; TODO: holder part number and price). A 30 A time-delay passes the 0.3 s 50 A jump pulse. Backup: Blue Sea 5191 MRBF block ($29.93 Amazon, catalog) with a 60 A MRBF, 58 VDC rated, acceptable only with the 55 V starting rule.
• Hold-to-run power cut: a 12 V-coil DC contactor in the pack's positive lead. TE Kilovac LEV100A4ANG (100 A, 900 VDC, 12 V coil 5.5 W): RS Components UK GBP 98.80 (65 ready, read today), Cytech $172.99 (500 available), no Digi-Key/Mouser stock found; the EV200AAANA (500 A) is GBP 174 at RS and 45 weeks at Digi-Key. TODO: a cheaper in-stock US source or a listed-price Amazon 100 A "EV relay" as the backup. Coil supply: the catalog's Mean Well DDR-30L-12 (18-75 V in, 12 V 2.5 A, $27.60 Bravo Electro) from the pack side of the fuse.
• Pre-charge: none needed with a contactor into two RS-04s (their input capacitance is small; the LEV100 is rated for it). Confirm on first power-up with a 10 ohm / 25 W resistor across the contacts for 1 s if the contactor welds or the pack adapter sparks.

3.3 The safety line (the turret bench's pendant pattern, docs/turret-plan.md section 2)

• Pendant: AbleNet Specs IC (normally-open momentary, 3.5 mm mono plug, 1.83 m cord), $75, in stock (alternates, today); backup Coyote Direct / Motion Raceworks sealed button with a 6 ft cord, $60 (needs a plug soldered on). It carries only the 12 V signal loop, never motor current.
• Loop -> hardware: pendant closed -> 12 V to (a) an off-delay timer relay set to 1.0 s (12 V DC, 1-10 s adjustable; TODO: part) that holds the contactor coil, and (b) an opto-isolated input on the Feather. Pendant released -> the Feather stops its RUN frame at once -> the laptop commands a 0.3 s sit-down to 150 mm then the RS-04 stop frame -> 1.0 s later the contactor opens whatever the software did. A power cut while standing is the collapse case, which the bottom bumper catches at 115 mm (section 2.1), so the hardware cut is always safe for the leg on the rig.
• Loop -> software: the laptop sends torque only while RUN frames are fresher than 50 ms; the Feather sends RUN at 100 Hz on an 11-bit ID (0x100) that cannot collide with the motors' 29-bit frames; an ARM command from the laptop is also required (the pendant alone starts nothing). Motor-side: set limit_torque to 60 N m in the motors' own firmware (the cap of D38, independent of the laptop) and the motor-side CAN watchdog (robstride_ros2 configures "a nonzero motor-side CAN watchdog on every activation"; TODO: its parameter name and index from the RS04 manual) so a hung laptop or an unplugged CAN lead stops the motors within 100 ms.

3.4 CAN, sensing, the rig node

• USB-CAN to the laptop: BIGTREETECH U2C V2.1 ($23.99, BIQU, orderable, candleLight-based gs_usb -> native SocketCAN can0; bitrate is set by ip link, 1 Mbit/s), backup FYSETC UCAN ($8, STM32F072, flash candleLight), the original CANable 2.0 is sold out at Openlight Labs; an isolated option is the InnoMaker USB2CAN (RS UK GBP 56.99, 3 kV isolation). 120 ohm termination at the adapter and at the far motor (the RS-04 has a selectable internal resistor on recent firmware; check can_status).
• Rig node: Adafruit Feather M4 CAN Express (ATSAME51, built-in CAN transceiver on a 3-pin terminal, 6 x 12-bit ADC, 5 V boost for the transceiver), $24.95, in stock (read today). Same board family as the turret (D41). It reads the pendant loop, a VL53L1X time-of-flight module on the carriage pointing at the deck (Adafruit 3967, $14.95, in stock, 30-4,000 mm, 50 Hz) for the carriage height, the HX711 (SparkFun SEN-13879, $4.95, in stock, 80 Hz) on the load plate, and sends them on the bus at 100 Hz.
• Carriage height: the ToF module at 50 Hz is enough for jump apex and rest heights; impact timing comes from the motors' 500 Hz feedback. Always also film at 240 fps against a millimetre tape on the post. A draw-wire sensor (CALT CWP-S series, 0-5 kohm, $125-140 for 1-2 m units on the sites read today; no 500 mm price found) is the upgrade if the ToF is not good enough.
• Ground force (slow tests): 4 x 50 kg half-bridge cells + HX711 kit (about $10 on Amazon, widely stocked; 200 kg as a full bridge); SparkFun's 200 kg S-type (SEN-14282, $96.95, in stock) with the same HX711 is the upgrade for the collapse test's 1.3 kN.
• Wiring a person can build from: 2 x 12 AWG silicone from the pack adapter -> fuse -> contactor -> an XT60 panel socket on a printed pod on the post (the turret stand's pod pattern: XT60E-F, rocker switch for the 12 V side, 3.5 mm jack for the pendant, the U2C inside, cad/turret_stand.py PANEL) -> the two RS-04 XT30 leads in parallel (each lead is 310 mm; a Y-splice with XT30 plugs at the carriage); CAN as one twisted pair daisy-chained adapter -> Feather -> motor 1 -> motor 2 (terminated at both ends) using the motors' GH1.25 plugs; the Feather on the laptop's USB for logs and power; grounds: the CAN ground is the pack negative (the RS-04's black lead), so a non-isolated USB-CAN ties the laptop ground to the pack negative — acceptable on a bench supply or a floating pack, use the isolated adapter if the laptop is on mains. Task T10 draws this as one page.

4. Software path: from sim/leg_rig.py to the motors

4.1 What is reused unchanged

fivebar.fk / ik / stance / jacobian / stop_angles and sim.leg_rig.vmc / Gains / clip_motor / pin_forces are the controller: a spring-damper on the virtual leg (kp_L 3,000 N/m, kd_L 250, kp_th 150 N m/rad, kd_th 6) with the gravity feed-forward ff = half_mass * g - (rotor + half the wheel link) * g, mapped by J^T to the two motors, each torque clipped to the RS-04's torque-speed line and the 60 N m cap. The scenario commands (command(): stand-up ramp, 0.5 Hz squat, the jump's crouch / push / tuck, the drop's hold) are reused too.

4.2 What is sim-only and must NOT be ported (the "firmware cancel" list)

• stop_torque() (the TPU sleeves as springs applied through qfrc_applied): a model of a real part; on hardware the sleeves are real. The controller never adds it.
• OFF_DAMPING (the assumed power-off damping): replaced by the measured curve; the controller never emulates it.
• ARMATURE, TYRE_SOLREF, STOP_K/STOP_B: model parameters, set from the bench tests (section 5), not control.
• The RS-04's own MIT loop: command with Kp = 0, Kd = 0 so the torque field is a pure feed-forward and the laptop's VMC is the only loop (a small Kd, 0.5-1 N m s/rad, is an acceptable safety damper during the first stand; log it). Anything the motor firmware adds (its limit_torque, speed limit, the damper parameter) is configuration, not control, and is written once and read back at start-up.

4.3 The RS-04 private protocol (29-bit extended IDs, 1 Mbit/s)

From the RobStride Python SDK README, the Seeed wiki, robstride_ros2 and the firmware release notes (all read today):

• Frame types (the ID's top bits): 0 get device ID, 1 motion control (MIT), 2 feedback, 3 enable, 4 stop, 6 set mechanical zero, 7 set CAN ID, 17 read parameter, 18 write parameter, 21/22 fault and baud, 24 active reporting (the motor answers every command with a type-2 feedback frame unless active reporting is on). Default motor ID 127; the leg uses IDs 1 (front) and 2 (rear).
• MIT frame encoding ranges for the RS04: position +-4 pi rad, velocity +-15 rad/s, torque +-120 N m, Kp 0-5000, Kd 0-100 (16-bit fields; the torque rides in the ID's data bits, position/velocity/Kp/Kd in the 8 data bytes, as in the CyberGear-family layout: verify the exact bit positions against RS04 User Manual 260713 section 4.1 in references/vendor or the RobStride Product_Information repo before coding, task T6).
• run_mode 0 = MIT (operation control), 1 = PP position, 2 = velocity, 3 = current, 5 = CSP. Parameters by name: run_mode, iq_ref, spd_ref, limit_torque, limit_spd, limit_cur, loc_ref, mechPos, mechVel, VBUS, loc_kp, spd_kp, spd_ki (indices in the manual section 4.3; the CyberGear family puts them at 0x7005-0x7020, verify). Feedback: angle, velocity, torque, temperature x10, fault bits (uncalibrated, stall, encoder, over-temperature, over-current, under-voltage) and mode bits.
• Damper parameter 0x2023 (RS04 firmware 0.4.1.6 and later): the unpowered back-drive protection; 1 disables it. The power-off test runs with it at 0 (default) and at 1.
• Use the 29-bit private protocol, not the separate 11-bit "MIT protocol" (motors silently ignore 11-bit frames on the private setting; a K-Bot community note). MotorStudio (Windows) or the SDK's CLI sets IDs and modes.
• Bus budget: 4 frames per tick (2 commands, 2 replies) is about 0.52 ms at 1 Mbit/s: 500 Hz uses half the bus.

4.4 Code layout (new files, the implementer's worktree)

• rig/rs04.py: frame pack/unpack for types 0-4, 6, 17, 18 with the RS04 ranges; Motor.enable/stop/zero/mit(pos, vel, kp, kd, tau); parameter read/write by name; a scan; CLI python -m rig.rs04 scan|enable|stop|param.
• rig/bus.py: class MotorBus with step(tau_f, tau_r) -> (phi_f, w_f, tau_meas_f, T_f, phi_r, ...) at a fixed tick; two backends: rig/can_bus.py (python-can SocketCAN) and rig/sim_bus.py (MuJoCo via sim.leg_rig.mjcf() stepped at 0.5 ms, 4 steps per tick).
• rig/leg_control.py: the VMC port (imports from cad/fivebar.py and sim/leg_rig.py); the scenario state machine; safety (RUN heartbeat, VBUS and temperature windows, torque cap, a leg-length window 95-395 mm, a rate limit on commanded torque).
• rig/run.py --backend sim|can --test stand|squat|jump|drop|power_off --half-mass 13.1 --log name: the runner.
• rig/log.py and rig/compare.py: 500 Hz logs to exports/rig/runs/<date>-<test>.npz + a JSON summary with the same keys as rig-results.json (peak_motor_nm, peak_motor_speed_rad_s, L_range_mm, jump_height_mm, ...), the measured series overlaid on the sim's series (which are at 10 ms), and pass/fail from rig/criteria.json.
• rig/firmware/feather_rig/: CircuitPython for the Feather (pendant input, RUN frame, VL53L1X, HX711, USB log).
• rig/bench/: backdrive.py, spin_down.py, fit_params.py (the measured curves to sim parameters).

4.5 Bring-up order

1. rig/run.py --backend sim reproduces rig-results.json (stand-up and squat peaks within 5 %, jump height within 10 mm) with the controller running through the bus abstraction at 500 Hz: proves the port.
2. One motor on the bench supply in the dyno fixture: scan, read parameters, enable, zero, MIT torque steps of 1-5 N m with Kp = Kd = 0, feedback at 500 Hz, loop jitter measured (target: 99 % of ticks within +-0.3 ms; if Python cannot, drop to 250 Hz for the first stand and move the loop to the Feather later).
3. Two motors in the hip frame on the rig, carriage on the bottom bumper, leg hanging: the controller holds a commanded length in the air (no ground), then the stand.

5. Bench test sequence (M3 list first), each with the sim's number and the pass/fail

Fixtures (task T4): the dyno pair, two printed PETG lug plates (10 x M4 on O106 with the two O5 dowel holes) on a plywood board holding the two RS-04s output-to-output through a printed coupler disc (9 x M5 + 3 pin sockets each side); an insert coupon (a PA6-CF block printed in the output adapter's orientation pa6_cf_z with M5 heat-set inserts); a post coupon (a PA6-CF block printed web-down like the hip frame, with the stop pin's Ø16 x 23 blind hole: the Ø16 x 40 pin set in it with Loctite 638, the TPU sleeve on it, pressed square by a flat anvil as the link's stop face presses it); a tyre cradle (the BotWheel on its 4 x M6 flange, pressed radially against a flat plate).

Order: B1-B5 as the motors arrive (B3, B4 need only coupons; B5 needs the wheel), then S1-S6. Every run writes exports/rig/runs/<date>-<test>.json with raw series and the criteria verdict.

6. Build package

6.1 BOM: leg (per leg), rig, electronics — primary and backup

Prices as read on the date given; the leg's McMaster lines are from catalog/hardware.json (2026-10-26) and exports/leg/bom.json; alternates from catalog/alternates.json (2026-10-27).

Leg, bought (per leg):

Leg, machined to order (per leg; D40, D46):

Leg bought total about $930 with the alternate bearings ($1,121 all-McMaster), plus the adapters (about $80 per leg) and filament about $300.

Rig (quantities for one rig):

Electronics:

Electronics about $330-470 depending on the contactor; rig about $400-500; whole first build about $2,400-2,700 plus the motors' shipping and duties.

6.2 Print plan on the P1S (hardened nozzle and extruder, textured PEI, glue; PA6-CF dried 8-12 h at 80 C before

every print, fed from a dry box, not the AMS)

Hours from exports/leg/print-plan.json (grams / density / 14 cm^3 per h for PA6-CF: rough, expect +20 %).

About 198 h of printing (the adapters are machined now): 9 days if nothing fails; plan three weeks with drying and one reprint. The motors' lead time from China (1-3 weeks) runs in parallel; the bench fixtures and coupons are done before the motors arrive.

6.3 SendCutSend

The rig's one part: the carriage plate (6061-T6, 0.25 in, 300 x 320 mm, hole table in section 2.1, deburred). The leg's machined parts (the two output adapters, CNC, D46) are ordered the same day from exports/leg/cnc/: JLCCNC or Xometry, the STEP plus the README's callouts. cad/build_rig.py exports exports/rig/sendcutsend/carriage_plate.dxf (flat, mm, holes as circles, no text) and the order sheet with the instant price read at upload. Everything else on the rig is extrusion, bought hardware or printed.

6.4 Assembly order (torques from B4; threadlocker on every screw into steel; never a hard press into PA6-CF)

0. On receipt (review M7): each O5 dowel must slip into the RS-04's locating holes by hand (drawn Ø5 0/-0.01; an m6 pin is +0.004/+0.012). If one does not, polish its motor end or buy -0.01 pins: the pins are pressed into the frame only, never into both. Depth-gauge one motor's lug threads too: the M4 x 20s take 4.9 mm (the drawing promises 5).
1. Hip frame: M5 inserts (6) set with the soldering iron at the coupon-proven temperature (the stop pins go in last, step 7); the two 61812s pressed in from the motor side onto the lip (light fit + retaining compound if the coupon says so); O5 dowels pressed into the frame's locating holes (the motor then slides onto them).
2. Output adapters (machined) onto the motors: the motor's 3 pins into the adapter's sockets, 9 x M5 x 25 (no washers: the heads sit in the pockets), threadlocker, the motor maker's torque; two O5 x 16 dowels pressed into each adapter's face (H7 holes, 8 mm in). Then each motor into the frame on its 2 dowels and 10 x M4 x 20 (heads 11 mm down in the counterbores), the adapter's j6 journal into the frame's 61812 with retaining compound (Loctite 641: it comes apart). The frame's dowel holes set each motor's turn so its harness leaves level and outwards (the front one forwards, 25 deg up; the rear one backwards, 11 deg down): check both clear the flanges.
3. Upper links: two eye sleeves pressed end to end from the outer face until the outer one is flush with that face (the press stops there: there is no floor under them; review S2); the link onto the adapter's face (over its 2 dowels and spigot, 8 x M5 x 40 into the tapped holes, heads in the hub's counterbores, B4 torque: the printed link under the heads sets the limit).
4. Knees: two 6201s and the spacer tube into each lower link's boss (cut each spacer to that boss's measured seat-to-seat distance + 0.03 mm, not to the nominal 28: review S4), a DIN 433 washer each side, the 12 x 90 shoulder screw from the outer side through the eye, the M10 nyloc in the pocket torqued onto the steel sleeve.
5. Apex (review M5: the hub's Ø64 shoulder is outboard of the outer bearing, so the bearings go in before the hub): the inner 61812 pressed into the front link from the inside, the apex spacer, the outer 61812 pressed from the outside against the web, then the wheel link's hub through both from the outside, the DIN 471-60 circlip.
6. Wheel: 4 x M6 x 30 from inside the hub (measure the flange's thread depth first; bom.json note), cable taped along the wheel link and rear upper link.
7. Stop pins, last (D53): each Ø16 x 40 pin, its vent flat turned to face its motor's axis (square to the stop's load) and its tapped end up, a thin coat of Loctite 638 in the 23 mm blind hole, pushed in by hand or a light press until it sits on the hole's floor (never a hard press into PA6-CF; the flat lets the air and compound out); wipe off what comes out, 24 h before a load. Then each TPU sleeve pushed on over its pin, its cap outwards (a stretch fit: no glue). Each post sits midway between two lug screws (front motor 43/79 and 187/223 deg, rear 101/137 and -43/-7 deg), 19 mm from its axis: a hex key reaches them past the sleeve's edge, and a sleeve pulls off by hand for a socket (review S8). A pin comes out with an M8 screw in its tapped end and a puller. Swing the leg by hand to both stops: each link's radial stop face meets its sleeve square on, no clash, free knees.
8. Carriage plate: blocks on (16 x M4), rods on, plate onto the frame's six inserts (M5 x 16); carriage onto the rails from the top, end caps on, tethers on; bumpers set at the 115 mm position, ballast plates to the rig.json figure.
9. Electrics: pod, fuse, contactor, pendant, CAN chain with both terminators, VBUS read on the laptop before any enable.
10. First power: bench supply at 48 V, current limit 5 A, carriage on the bumper, leg in the air: scan, parameters, limit_torque 60, zero both motors at a jig-defined pose (upper links horizontal on the knee-out stops is the simplest reference: phi = +3 deg / -183 deg), enable, hold a length in the air, then the stand.

7. Ordered task list for the Opus implementer

Work in your own worktree on new files; cad/fivebar.py, cad/leg_studies.py and sim/leg_rig.py are the main session's (requests to them are the F items at the end). Estimates are working days.

Flagged for the main session (owner of fivebar.py, leg_studies.py, sim/leg_rig.py):

• F1 sim/leg_rig.py: take the rail position, rail_low (bumper height) and the carriage mass from exports/rig/rig.json; add a damping-curve option b(omega) from B1 and a sweep that reports the knee force against b (the D39 decision); refit ARMATURE, STOP_K/STOP_TRAVEL, TYRE_SOLREF from B2, B3, B5.
• F2 cad/leg_studies.py: re-run so summary.json matches the 07:50 rig results (R3 as the fault case at SF 1.0); HUB_PRELOAD_N from B4; a damped-collapse case once B1 is in.
• F3 cad/fivebar.py (optional): expose frame_mounts() returning the six insert positions and the mount plane so T2 does not duplicate hip_frame()'s constants; check the harness grommet clocking against a plate at y = -82.3.
• F4 (optional) move vmc / Gains / clip_motor into a MuJoCo-free module so the laptop controller does not import mujoco.

First five for the implementer, in order: T1, T2, T4 (so the fixtures print while parts ship), T6, T7 — then T8/T9 as a pair, T10/T11 as a pair.

8. Top risks

1. RS-04 supply: five sellers, all China; two backordered 4-6 weeks. Order on day 1 from Seeed (or OpenELAB with duties included) and nothing else on the plan waits on the motors except the bench tests.
2. PA6-CF on a P1S at the hip frame's size (274 x 148, 782 g, turned 45 deg): warping and layer adhesion without a heated chamber. Mitigation: coupons and a test slab first, textured PEI with glue, the chamber pre-warmed, the frame printed last; the fallback is splitting the frame (a fivebar change, main session).
3. Bearing seats in printed PA6-CF crack on a hard press (LeRobot) or walk when loose: the coupons set a light fit; retaining compound as the backup.
4. The power-off collapse is the knees' governing case and depends on one unmeasured motor behaviour: B1 is first, the bumper stays high until it is known, and the spring add-on is on the shelf.
5. Regen over-voltage on a 60 V-limited motor: no bench-supply dynamics, the pack at 48-55 V, VBUS watched every tick, a 58 V abort.
6. A 500 Hz Python loop over USB-CAN may jitter: measured in bring-up step 2; 250 Hz is acceptable for the first stand (the sim can confirm the margin at 250 Hz: F1), and the Feather is the landing place for a 1 kHz loop.
7. The hold-to-run contactor: the proper parts are GBP 99-174 and not all in US stock; the backup is a listed-price Amazon EV relay, to be verified, or the AC-side cut when on the bench supply.
8. The rail blocks' roll moment (880 N m at the jump) and rail alignment: two rails on one post face, blocks 250 mm apart, checked in T2; loosen-and-retighten alignment on assembly, and the first jumps at 30 N m.
9. Insert preload in PA6-CF is an assumption (1,200 N) behind the hub joint checks: B4 before the adapters are torqued.
10. The motor harness clocking against the carriage plate (2 mm behind the motors' rear faces): T2 checks the vendor STEP; the plate's top slot is the escape.

9. TODO (next session)

• Fill the TODO prices: MISUMI US configurator (HFS8-8080 x 1,200, 4040 lengths, brackets, T-nuts), a Class CC fuse holder, the 12 V off-delay timer, a US-stock contactor backup, the ballast rod and collar part numbers.
• Verify the RS-04 MIT frame bit layout, the parameter indices and the CAN-watchdog parameter name against the RS04 manual 260713 section 4 (the PDF in the RobStride Product_Information repo; GitHub returned 403 to the fetch tool today, so read it from references/vendor/ or a browser).
• Read one Amazon HGR15/HGR20 rail-set listing live for a US price and delivery.
• Decide whether the first stand runs at 500 or 250 Hz once the loop jitter is measured.
• The site page (T14) conventions: check designer/ for the shared top bar before writing it.