Writing your own

Extend Follower on the machine that moves and Leader on the one that drives. The session, safety, correlation and recording come with them.

Follower

Three methods are required. The rest are there when your hardware needs them.

from typing import Mapping
from videosdk_teleop import Follower, Units, single_group_descriptor

JOINTS = ("shoulder", "elbow", "wrist", "gripper")


class MyArm(Follower):
    def __init__(self, meeting_id, port, **kw):
        self.robot_id = "my-arm"
        self.port = port
        self._bus = None
        super().__init__(meeting_id, **kw)         # LAST

    def descriptor(self):
        return single_group_descriptor(self.robot_id, "my-arm", JOINTS,
                                       control_hz=50, units=Units.DEG)

    def limits(self) -> Mapping[str, tuple[float, float]]:
        return {"shoulder": (-90.0, 90.0), "elbow": (-120.0, 120.0),
                "wrist": (-180.0, 180.0), "gripper": (0.0, 40.0)}

    def connect(self) -> None:
        self._bus = open_my_bus(self.port)         # your driver

    def disconnect(self) -> None:
        if self._bus is not None:
            self._bus.close()
            self._bus = None

    def read_joints(self) -> Mapping[str, float]:
        return self._bus.read_all()                # raises on failure

    def write_joints(self, joints: Mapping[str, float]) -> None:
        self._bus.write_all(joints)

    def telemetry(self) -> Mapping[str, Mapping[str, float]]:
        return {"load": self._bus.read_load()}

    def torque_enable(self, on: bool) -> None:
        self._bus.set_torque(on)

Leader

Two methods, and nothing to write.

from videosdk_teleop import Leader, Units, single_group_descriptor


class MyController(Leader):
    def __init__(self, meeting_id, port, **kw):
        self._device = open_my_device(port)        # no connect() hook here
        super().__init__(meeting_id, **kw)         # LAST

    def descriptor(self):
        return single_group_descriptor("my-controller", "my-arm", JOINTS,
                                       control_hz=50, units=Units.DEG)

    def read_joints(self) -> Mapping[str, float]:
        return self._device.pose()

The leader has no connect() or disconnect(). Open your device in __init__, and close it when your program ends.

Rules

Call super().__init__() last. It runs your descriptor() and limits(), so anything they use has to exist by then.

Let failures raise. If the bus does not answer, raise. The follower stops the arm, which is safe. Returning the last known position instead leaves it moving on numbers that are no longer true.

Add torque_enable() before setting on_starvation=TORQUE_OFF. Without it, construction fails rather than promising to cut power it cannot cut.

Three smaller ones:

Keep your reads and writes quick. Both have to finish inside one tick, 20 ms at 50 Hz. Slower shows up as overruns in stats().
Report the units you really use. slew, limits() and every recorded row are read in whatever your descriptor says.
Share your joint names between the two machines. Put them in one module both import, since a follower and leader that disagree cannot run together.

Follower

Every constructor argument, and the methods you can override.

Custom

The same thing as a guide, with a working two-machine example.

Get started

Classes

Adapters

Writing your own

Follower

Leader

Rules

Follower

Custom

​Follower

​Leader

​Rules

​Related

Follower

Custom

Follower

Leader

Rules

Related