Skate Commander — Docs & rbt API reference

Quick start

No hardware needed — it runs sim-first in MuJoCo.

# 1. the cockpit
git clone https://github.com/dsl-robotics/skatearm.git
cd skatearm/tools/skate_commander

# 2. the official robot model — once (meshes aren't redistributed)
git clone https://github.com/Rbotic/skate_teleop.git

# 3. install + launch
pip install -r requirements.txt mujoco
python3 -m skate_commander

On first run it auto-finds the skate_teleop model, builds the sim + collision models once, starts the sim endpoint, and opens the cockpit at http://127.0.0.1:8088 → press RESUME. Windows: use py -m pip install … and py -m skate_commander — a bare python/pip may be missing or open the Microsoft Store stub.

Drive a real Skate instead: python3 -m skate_commander --real (add --real-host <ip> if it isn't r.local).

The cockpit

An NVIDIA-Isaac-Sim-style robotics workstation, in the browser: a menu bar, a left vertical tool rail, a center 3D view, a right STAGE (scene hierarchy) over PROPERTY (inspector), and a bottom TIMELINE / CONSOLE / CONTENT browser — flat, token-driven dark theme. Everything goes over the same UDP wire the robot speaks, so the twin and the real robot are one switch apart.

Motion & IK

Jog & sliders — hold −/+, drag the thumb, or jump to a limit. Amber = your command, azure = the actual position.
Cartesian jog — step the tool point (TCP) along world X/Y/Z (1–50 mm); server-side IK, auto-stops on arrival.
Drag-IK gizmo — grab a wrist in 3D; damped-least-squares IK glides the seven arm joints with null-space comfort (relaxing the redundant freedom toward a natural pose) — plus grid/angle snap (10 mm / 15°) and an on-drag coordinate HUD.
Mirror & dual-arm carry — one input drives both arms (sign map measured from the model); CARRY holds one object with both wrists and moves them together.
Smooth, acceleration-limited motion — jog and replay ease in/out (trapezoidal velocity, no abrupt steps); safety stops still drop motion instantly.
Plan around self-collisions (RRT-Connect) — Home and waypoint glides route around a self-collision the straight path can't pass, instead of giving up.
Contact reflex — a torque spike while barely moving latches a soft-stop (pushing into an obstacle, not a fast commanded move).
Global speed override — a teach-pendant SPD slider scales all motion (jog + every glide) server-side.

Programs & teaching

Teach-in (● REC) — move the robot; every settled pose becomes a line of rbt code.
Sequencer — record poses, play with pause/loop, save/load named sequences.
Python programs — the rbt API (below) with Click-to-Step, autocomplete and ready examples.
Control flow — a + FLOW snippet bar (repeat / while / if / wait) with rbt.ok() / blocked() / contact() / near() condition helpers.
Tools & traces — named end-of-arm TCP offsets; colored tool-path traces in the viewport.

Manipulability & previews

Manipulability heat-map (DEX) — a dexterity cloud over the arm's workspace: warm = isotropic, blue = near-singular; a SING chip warns at near-straight poses.
Ghost-robot move preview — risky moves (Home, waypoints, smart-pick) draw a translucent ghost at the target pose, with the planned collision-free route, behind an Approve / Cancel gate.

Scene & planning

Scene markers — spawn a target in reachable space and drag its 3D gizmo; live reachability, one-click →L / →R go-to, →P to a program, and ⇄ bimanual reach.
Virtual keep-out obstacles — spawn boxes of any size and place them with a 3D gizmo; the RRT-Connect planner and the collision guard route the arms around them.
Planning preview — a translucent ghost robot at the destination plus the planned collision-free route, gated behind Approve / Cancel for Home and waypoint moves.
Save / load scene — save the placed markers + obstacles to a JSON scene file and reload them later.

Vision & depth in development

Sim-validated, re-enabling with a real depth camera (the vision backend stays in the tree as reference): a work-camera point cloud (PCL), multi-object smart-pick grasp synthesis (SMART) with a colour/shape detector (optional YOLO), vision-guided pick (DETECT → PICK) and closed-loop visual servoing (SERVO: open-loop ~43 mm vs IBVS ~5 mm in sim).

Inspection & telemetry RViz · Foxglove · Isaac

Live telemetry plots — Foxglove-style scrolling strip charts (joint angle / velocity / temperature / TCP) at the 20 Hz UI rate, with a colour legend, pause and auto-ranging.
Live TF frame tree — RViz-style transform tree with world-mm readouts and eye-toggled RGB axis triads (frame-labelled) that track the kinematics.
Diagnostics + joint-limit meters — an RViz robot_monitor-style status tree (link / E-STOP / overtemp / guard / contact + per-joint temp/vel/load), and per-joint slider meters that tint amber/red near a limit.
Collision-mesh + TCP-force overlays — render the guard's capsule/box collision model (contacts reddened) and a per-arm end-effector force arrow estimated from the joint torques.
Trajectory replay + CSV export — a 45 s rolling joint record with a scrubber and a playhead on the plots; export the current signal or the full 26-DoF trajectory to CSV.
Sim transport — Play / Pause / Stop / Step / Reset with a run clock and real server-side pause and single-step.
Measure, stats & search — a click-two-points measure tool, an FPS / draw-calls / triangles HUD, a Stage-tree search, and a selection outline around the picked arm.
Views & presets — a nav gizmo + Persp/Top/Front/Side, saveable view presets, an ego + exo split view, and a live link RTT + bandwidth readout (round-trip ping over the WebSocket).

Safety & access

Collision guard — every target is checked for self-collision (incl. arm-vs-arm) along the interpolated path (0.05 rad steps), not just at the endpoints, before it is sent.
Accessible — real ARIA sliders, keyboard control, a screen-reader-aware status cluster, operator hotkeys + a legend, and a motion-pause control.
SIM / REAL — same protocol either way; switching always re-latches the E-STOP.

Programs — the `rbt` API

Write Python in the PROG tab. Every motion runs through the same safe bridge as the panel — joint limits, the collision guard, E-STOP and overtemp all apply. RUN runs free; Click-to-Step pauses before each motion command; E-STOP or any manual panel input stops the program.

Call	What it does
`rbt.movej(joint, deg)`	Move one joint to an absolute angle (degrees). `joint` = "L1"–"L8", "R1"–"R8", "H1"/"H2", a URDF joint name, or a protocol index.
`rbt.pose({joint: deg, …})`	Move several joints together as one coordinated motion (one guard check, no mirroring).
`rbt.movel(arm, dx=, dy=, dz=)`	Glide the TCP a relative step in mm along world X/Y/Z. `arm` = "left"/"right". Auto-stops when blocked.
`rbt.moveto(arm, x, y, z)`	Glide the TCP to an absolute world point (mm) — same IK + guard as the drag-gizmo.
`rbt.moveto(arm, x, y, z, roll, pitch, yaw)`	…and hold a wrist orientation there too (degrees, fixed-axis — the URDF's convention, and the gizmo's). All three angles or none: a pose is a stricter request than the point it grew out of, so it can take longer or be refused where the point alone would go.
`rbt.home()`	Glide to the documented safe pose.
`rbt.gripper(arm, deg)`	Open/close one gripper (degrees). Same as `movej("R8"/"L8", deg)`.
`rbt.waypoint(i_or_name)`	Glide to a recorded sequencer pose (1-based index or saved name).
`rbt.wait(seconds)`	Dwell.
`rbt.tcp(arm="right")`	Read the current TCP position (world mm).
`rbt.tcp_rpy(arm="right")`	Read the wrist orientation back as (roll, pitch, yaw) degrees — the same three numbers `moveto` takes, so a pose jogged by hand can be read off here and pasted into a program that reproduces it.
`rbt.q()`	Read all 26 commanded joint angles (degrees).
`rbt.status()`	Read the full state snapshot.

Units: joints in degrees, cartesian in millimeters, wrist orientation in fixed-axis roll/pitch/yaw degrees, world axes. Joints: L1–L8 left arm, R1–R8 right arm, H1–H2 head (16 of the 26-DoF body are the two arms). Sandbox: rbt, math and safe builtins (range, len, min, max, abs, round, enumerate, zip, sum, sorted, print…) — no imports or file access.

Example

rbt.home()
rbt.gripper("right", 30)            # open
rbt.moveto("right", 130, 350, 35)   # above the part
rbt.moveto("right", 130, 350, -43)  # down to it
rbt.gripper("right", 0)             # close
rbt.moveto("right", 130, 350, 75)   # lift
rbt.home()

The PROG tab has rbt. autocomplete (or Ctrl-Space) and a menu of ready examples.