Jogging and servoing

Streamed motion: takes the arm at once and cancels the planned queue (MOTN_CANCELLED for every discarded command). A jog ends when its duration runs out; a servo stream ends about 0.25 s after the last target. Then the arm brakes to rest. Speeds are signed fractions in [−1, 1] for jogs and fractions in (0, 1] for servo targets. jog_j works before homing; jog_l and the servo targets need a homed robot. Jogging and servoing in the guide.

jog_j

rbt.jog_j(
    joint: int | None = None,
    speed: float = 0.0,
    duration: float = 0.1,
    *,
    joints: list[int] | None = None,
    speeds: list[float] | None = None,
    accel: float = 0.5,
) -> int

Joint velocity jog. Single-joint or multi-joint.

Single joint: jog_j(0, 0.5, 1.0) Multi joint: jog_j(joints=[0,1], speeds=[0.5, -0.3], duration=1.0)

rbt.jog_j(0, speed=0.5, duration=1.0)

Parameter	Meaning
joint	Joint index (0-5) for single-joint jog
speed	Signed speed fraction for single-joint jog
duration	Jog duration in seconds
joints	List of joint indices for multi-joint jog
speeds	List of signed speed fractions for multi-joint jog
accel	Acceleration fraction 0-1

jog_l

rbt.jog_l(
    frame: Frame,
    axis: Axis | None = None,
    speed: float = 0.0,
    duration: float = 0.1,
    *,
    axes: list[Axis] | None = None,
    speeds_list: list[float] | None = None,
    accel: float = 0.5,
) -> int

Cartesian velocity jog. Single-axis or multi-axis.

Single axis: jog_l("WRF", "X", 0.5, 1.0) Multi axis: jog_l("WRF", axes=["X","Y"], speeds_list=[0.5, -0.3], duration=1.0)

rbt.jog_l("WRF", "X", speed=0.5, duration=1.0)

Parameter	Meaning
frame	Reference frame ("WRF" or "TRF")
axis	Axis name for single-axis jog
speed	Signed speed fraction for single-axis jog
duration	Jog duration in seconds
axes	List of axis names for multi-axis jog
speeds_list	List of signed speed fractions for multi-axis jog
accel	Acceleration fraction 0-1

Note

Axis names: X, Y, Z, RX, RY, RZ; frames WRF and TRF. Jogs are clamped to 80 % of the limits.

servo_j

rbt.servo_j(
    angles: list[float] | None = None,
    *,
    pose: list[float] | None = None,
    speed: float = 0.5,
    accel: float = 0.5,
) -> int

Streaming joint position target. Fire-and-forget.

The stream stops about 0.25 s after the last target arrives: the arm brakes to rest and holds there.

rbt.servo_j([90, -90, 180, 0, 0, 180])

Parameter	Meaning
angles	6 joint angles in degrees (ignored if pose= is set)
pose	If set, Cartesian target — dispatches to SERVOJ_POSE
speed	Speed fraction 0-1
accel	Acceleration fraction 0-1

servo_l

rbt.servo_l(pose: list[float], *, speed: float = 0.5, accel: float = 0.5) -> int

Streaming linear Cartesian position target. Fire-and-forget.

The stream stops about 0.25 s after the last target arrives: the tool brakes along its line to rest and holds there.

rbt.servo_l([0, 263, 242, 90, 0, 90])

Parameter	Meaning
pose	Target [x,y,z,rx,ry,rz] in mm and degrees
speed	Speed fraction 0-1
accel	Acceleration fraction 0-1

stream_status (async client only)

rbt.stream_status() -> AsyncIterator[StatusBuffer]

Async generator that yields status updates from multicast broadcasts.

async for status in client.stream_status():
    print(f"Angles: {status.angles}")

This generator terminates automatically when close is called on the client, so callers do not need to manually cancel their consumer tasks.

Each yielded StatusBuffer is a copy - safe to store or process async. For zero-copy hot paths, use stream_status_shared instead.

Slow consumers automatically skip to the latest state (desired for real-time).

stream_status_shared (async client only)

rbt.stream_status_shared() -> AsyncIterator[StatusBuffer]

Zero-copy async generator that yields the shared status buffer.

async for status in client.stream_status_shared():
    # Process immediately - don't store references
    print(f"Angles: {status.angles}")

WARNING: The same buffer instance is yielded on every iteration. Do not store references to the yielded object - data will be overwritten on the next iteration. For safe storage, use stream_status or call status.copy().

This generator terminates automatically when close is called on the client.

Slow consumers automatically skip to the latest state (desired for real-time).

Comments

---

Found a mistake on this page? Edit it on GitHub · Report it · Get help · This page as Markdown · llms.txt · The whole manual as PDF