viam.components.arm

Submodules

Attributes

KinematicsReturn

Classes

`KinematicsFileFormat`
`Mesh`	Abstract base class for protocol messages.
`Pose`	Pose is a combination of location and orientation.
`JointPositions`	Abstract base class for protocol messages.
`MoveOptions`	MoveOptions specifies kinematic constraints for an arm motion. All fields
`Arm`	Arm represents a physical robot arm that exists in three-dimensional space.

Package Contents

viam.components.arm.KinematicsReturn

class viam.components.arm.KinematicsFileFormat: Bases: _KinematicsFileFormat

class viam.components.arm.Mesh(*, content_type: str = ..., mesh: bytes = ...)

Bases: google.protobuf.message.Message

Abstract base class for protocol messages.

Protocol message classes are almost always generated by the protocol compiler. These generated types subclass Message and implement the methods shown below.

content_type: str: Content type of mesh (e.g. ply)

mesh: bytes: Contents of mesh data in binary form defined by content_type

class viam.components.arm.Pose(*, x: float = ..., y: float = ..., z: float = ..., o_x: float = ..., o_y: float = ..., o_z: float = ..., theta: float = ...)

Bases: google.protobuf.message.Message

Pose is a combination of location and orientation. Location is expressed as distance which is represented by x , y, z coordinates. Orientation is expressed as an orientation vector which is represented by o_x, o_y, o_z and theta. The o_x, o_y, o_z coordinates represent the point on the cartesian unit sphere that the end of the arm is pointing to (with the origin as reference). That unit vector forms an axis around which theta rotates. This means that incrementing / decrementing theta will perform an inline rotation of the end effector. Theta is defined as rotation between two planes: the first being defined by the origin, the point (0,0,1), and the rx, ry, rz point, and the second being defined by the origin, the rx, ry, rz point and the local Z axis. Therefore, if theta is kept at zero as the north/south pole is circled, the Roll will correct itself to remain in-line.

x: float: millimeters from the origin

y: float: millimeters from the origin

z: float: millimeters from the origin

o_x: float: z component of a vector defining axis of rotation

o_y: float: x component of a vector defining axis of rotation

o_z: float: y component of a vector defining axis of rotation

theta: float: degrees

class viam.components.arm.JointPositions(*, values: collections.abc.Iterable[float] | None = ...)

Bases: google.protobuf.message.Message

Abstract base class for protocol messages.

Protocol message classes are almost always generated by the protocol compiler. These generated types subclass Message and implement the methods shown below.

values() → google.protobuf.internal.containers.RepeatedScalarFieldContainer[float]: A list of joint positions. Rotations values are in degrees, translational values in mm. There should be 1 entry in the list per joint DOF, ordered spatially from the base toward the end effector of the arm

class viam.components.arm.MoveOptions(*, max_vel_degs_per_sec: float | None = ..., max_acc_degs_per_sec2: float | None = ..., max_vel_degs_per_sec_joints: collections.abc.Iterable[float] | None = ..., max_acc_degs_per_sec2_joints: collections.abc.Iterable[float] | None = ..., max_tcp_speed: float | None = ...)

Bases: google.protobuf.message.Message

MoveOptions specifies kinematic constraints for an arm motion. All fields are optional ceilings; any combination may be set. Every constraint that is set is respected at every point along the executed trajectory. The limiting constraint may change throughout execution.

max_vel_degs_per_sec: float: Maximum allowable velocity of an arm joint, in degrees per second. The arm driver will move as fast as possible up to the set value. Ignored when max_vel_degs_per_sec_joints is set.

max_acc_degs_per_sec2: float: Maximum allowable acceleration of an arm joint, in degrees per second squared. The arm driver will accelerate as fast as possible up to the set value. ignored when max_acc_degs_per_sec2_joints is set.

max_tcp_speed: float: Maximum allowable speed of an arm’s tool center point in meters per second. The arm driver will move the tool center point as fast as possible up to this set value.

max_vel_degs_per_sec_joints() → google.protobuf.internal.containers.RepeatedScalarFieldContainer[float]: Per-joint maximum velocity in degrees per second. The arm driver will move each joint as fast as possible up to its respective set value.

max_acc_degs_per_sec2_joints() → google.protobuf.internal.containers.RepeatedScalarFieldContainer[float]: Per-joint maximum acceleration in degrees per second squared. The arm driver will accelerate each joint as fast as possible up to its respective set value.

HasField(field_name: _HasFieldArgType) → bool

Checks if a certain field is set for the message.

For a oneof group, checks if any field inside is set. Note that if the field_name is not defined in the message descriptor, ValueError will be raised.

Parameters:: field_name (str) – The name of the field to check for presence.
Returns:: Whether a value has been set for the named field.
Return type:: bool
Raises:: ValueError – if the field_name is not a member of this message.

WhichOneof(oneof_group: _WhichOneofArgType__max_acc_degs_per_sec2) → _WhichOneofReturnType__max_acc_degs_per_sec2 | None

WhichOneof(oneof_group: _WhichOneofArgType__max_tcp_speed) → _WhichOneofReturnType__max_tcp_speed | None

WhichOneof(oneof_group: _WhichOneofArgType__max_vel_degs_per_sec) → _WhichOneofReturnType__max_vel_degs_per_sec | None

Returns the name of the field that is set inside a oneof group.

If no field is set, returns None.

Parameters:: oneof_group (str) – the name of the oneof group to check.
Returns:: The name of the group that is set, or None.
Return type:: str or None
Raises:: ValueError – no group with the given name exists

class viam.components.arm.Arm(name: str, *, logger: logging.Logger | None = None)[source]

Bases: viam.components.component_base.ComponentBase

Arm represents a physical robot arm that exists in three-dimensional space.

This acts as an abstract base class for any drivers representing specific arm implementations. This cannot be used on its own. If the __init__() function is overridden, it must call the super().__init__() function.

from viam.components.arm import Arm
# To use move_to_position:
from viam.components.arm import Pose
# To use move_to_joint_positions and move_through_joint_positions:
from viam.components.arm import JointPositions
# To use move_through_joint_positions:
from viam.components.arm import MoveOptions
# To use get_3d_models:
from viam.components.arm import Mesh

For more information, see Arm component.

type Properties = GetPropertiesResponse

API: Final: The API of the Resource

class KinematicConstraints[source]

Optional per-waypoint kinematic constraints attached to a TrajectoryPoint.

Velocities are required whenever constraints are present; accelerations are optional and may only be given alongside velocities. Each list runs from the base joint out to the end effector and must match the arm’s degrees of freedom.

velocities: list[float]: Target joint velocities at this waypoint. Rotational values in degrees per second, translational values in mm per second.

accelerations: list[float] | None = None: Optional target joint accelerations at this waypoint. Rotational values in degrees per second squared, translational values in mm per second squared.

class TrajectoryPoint[source]

A single waypoint of a kinematized trajectory, as consumed by move_through_joint_positions_streamed.

Point times must strictly increase across a stream, and the first point must have a time of zero.

time: datetime.timedelta: Time at which this waypoint should be reached, measured from the start of the motion.

positions: list[float]: Joint positions at this waypoint. Rotational values in degrees, translational values in mm.

constraints: Arm = None: Optional kinematic constraints at this waypoint.

to_proto() → viam.proto.component.arm.TrajectoryPoint[source]

classmethod from_proto(proto: viam.proto.component.arm.TrajectoryPoint) → Arm[source]

class TrajectoryUpdate[source]

An update reported by the arm as it executes a move_through_joint_positions_streamed trajectory.

The type is intentionally empty. The response is a oneof whose only branch today is an empty BatchAck, so receiving a response is itself the acknowledgment. The oneof exists so the arm’s replies can grow new branches without breaking existing clients on the wire; when a branch carries data worth surfacing (BatchAck’s extra, or a new branch entirely), this type grows to match.

to_proto() → viam.proto.component.arm.MoveThroughJointPositionsStreamedResponse[source]

classmethod from_proto(proto: viam.proto.component.arm.MoveThroughJointPositionsStreamedResponse) → Arm[source]

abstractmethod get_end_position(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → viam.components.arm.Pose[source]

Async:

Get the current position of the end of the arm expressed as a Pose.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Get the end position of the arm as a Pose.
pos = await my_arm.get_end_position()

Returns:: A representation of the arm’s current position as a 6 DOF (six degrees of freedom) pose. The Pose is composed of values for location and orientation with respect to the origin. Location is expressed as distance, which is represented by x, y, and z coordinate values. Orientation is expressed as an orientation vector, which is represented by o_x, o_y, o_z, and theta values.
Return type:: Pose

For more information, see Arm component.

abstractmethod move_to_position(pose: viam.components.arm.Pose, *, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Move the end of the arm to the Pose specified in pose.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Create a Pose for the arm.
examplePose = Pose(x=5, y=5, z=5, o_x=5, o_y=5, o_z=5, theta=20)

# Move your arm to the Pose.
await my_arm.move_to_position(pose=examplePose)

Parameters:: pose (Pose) – The destination Pose for the arm. The Pose is composed of values for location and orientation with respect to the origin. Location is expressed as distance, which is represented by x, y, and z coordinate values. Orientation is expressed as an orientation vector, which is represented by o_x, o_y, o_z, and theta values.

For more information, see Arm component.

abstractmethod move_to_joint_positions(positions: viam.components.arm.JointPositions, *, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Move each joint on the arm to the corresponding angle specified in positions.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Declare a list of values with your desired rotational value for each joint on
# the arm. This example is for a 5dof arm.
degrees = [0.0, 45.0, 0.0, 0.0, 0.0]

# Declare a new JointPositions with these values.
jointPos = JointPositions(values=degrees)

# Move each joint of the arm to the position these values specify.
await my_arm.move_to_joint_positions(positions=jointPos)

Parameters:: positions (JointPositions) – The destination JointPositions for the arm.

For more information, see Arm component.

abstractmethod move_through_joint_positions(positions: list[viam.components.arm.JointPositions], options: viam.components.arm.MoveOptions | None = None, *, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Move the arm through the given joint positions in the order they are specified, obeying the velocity and acceleration limits in options.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Move through two waypoints, capping joint speed and acceleration.
await my_arm.move_through_joint_positions(
    positions=[
        JointPositions(values=[0, 45, 0, 0, 0, 0]),
        JointPositions(values=[0, 0, 0, 0, 0, 0]),
    ],
    options=MoveOptions(max_vel_degs_per_sec=15.0, max_acc_degs_per_sec2=30.0),
)

Parameters:

positions (List[JointPositions]) – The waypoints to move through, in order.
options (Optional[MoveOptions]) – Optional kinematic ceilings obeyed at every point along the trajectory. None means no limits are requested.

Note

Unlike the Go SDK, this method does not validate the requested positions against the arm’s joint limits before sending them, because the Python SDK cannot yet parse a kinematics model. Implementations are responsible for their own limit checking.

Every scalar field on MoveOptions (max_vel_degs_per_sec, max_acc_degs_per_sec2, max_tcp_speed) also has explicit presence: an unset field reads back as 0.0, indistinguishable from an explicitly-set zero. Implementations must check options.HasField("max_vel_degs_per_sec") (and likewise for the other scalar fields) before applying it as a ceiling — reading an unset field’s 0.0 directly would misread “no limit requested” as “do not move”. Per the proto definition, max_vel_degs_per_sec is ignored whenever max_vel_degs_per_sec_joints is set, and likewise max_acc_degs_per_sec2 is ignored whenever max_acc_degs_per_sec2_joints is set; implementations should honor only the per-joint limit in that case, not both.

An empty positions list is passed through to the implementation unchanged; implementations must handle it, typically as a no-op.

For more information, see Arm component.

abstractmethod move_through_joint_positions_streamed(batches: collections.abc.AsyncIterator[list[Arm]], *, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → collections.abc.AsyncIterator[Arm][source]

Async:

Move the arm through a time-parameterized stream of joint waypoints.

The caller supplies an asynchronous iterator of batches, each batch a list of TrajectoryPoint. Each list the caller yields is sent as one wire TrajectoryBatch, so the caller sets the wire cadence by choosing how many points go in each list; a caller that wants to send one point at a time yields a single-element list. The arm’s updates are yielded back as they arrive, so iterating the return value observes execution in real time. If the arm faults mid-trajectory, that fault arrives as a gRPC error on the iteration, so the async for raises instead of ending normally. Delivering faults mid-execution, not only at the end, is the point of streaming this call.

The first point of the stream must have time zero, and if it carries velocity constraints those velocities must all be zero, since the trajectory starts from rest. Point times must strictly increase across the whole stream, not merely within a batch. A timeout, if given, bounds the entire stream, not a single message, so an open-ended trajectory should normally leave it unset.

An implementation must yield at least one TrajectoryUpdate before returning. Besides reporting progress, this is what makes the implementation an asynchronous generator; a coroutine that never yields cannot be iterated as a stream and fails at runtime.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

async def batches():
    yield [
        Arm.TrajectoryPoint(time=timedelta(seconds=0.0), positions=[0.0, 0.0, 0.0, 0.0, 0.0]),
        Arm.TrajectoryPoint(time=timedelta(seconds=1.0), positions=[10.0, 0.0, 0.0, 0.0, 0.0]),
    ]

async for update in my_arm.move_through_joint_positions_streamed(batches()):
    # Observe the arm's updates; a fault raises out of this iteration.
    pass

Parameters:: batches – an asynchronous iterator of lists of TrajectoryPoint. Each list becomes one wire TrajectoryBatch.
Returns:: the arm’s updates, yielded as they arrive.
Return type:: AsyncIterator[Arm.TrajectoryUpdate]

abstractmethod get_joint_positions(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → viam.components.arm.JointPositions[source]

Async:

Get the JointPositions representing the current position of the arm.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Get the current position of each joint on the arm as JointPositions.
pos = await my_arm.get_joint_positions()

Returns:: The current JointPositions for the arm. JointPositions can have one attribute, values, a list of joint positions with rotational values (degrees) and translational values (mm).
Return type:: JointPositions

For more information, see Arm component.

abstractmethod stop(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Stop all motion of the arm. It is assumed that the arm stops immediately.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Stop all motion of the arm. It is assumed that the arm stops immediately.
await my_arm.stop()

For more information, see Arm component.

abstractmethod is_moving() → bool[source]

Async:

Get if the arm is currently moving.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Stop all motion of the arm. It is assumed that the arm stops immediately.
await my_arm.stop()

# Print if the arm is currently moving.
print(await my_arm.is_moving())

Returns:: Whether the arm is moving.
Return type:: bool

For more information, see Arm component.

abstractmethod get_kinematics(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → viam.components.KinematicsReturn[source]

Async:

Get the kinematics information associated with the arm.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Get the kinematics information associated with the arm.
kinematics = await my_arm.get_kinematics()

# Get the format of the kinematics file.
k_file = kinematics[0]

# Get the byte contents of the file.
k_bytes = kinematics[1]

Returns:: A tuple containing two values; the first [0] value represents the format of the file, either in URDF format (KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF) or Viam’s kinematic parameter format (spatial vector algebra) (KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA), and the second [1] value represents the byte contents of the file. If available, a third [2] value provides meshes keyed by URDF filepath. See get_3d_models for meshes keyed by model name instead.
Return type:: Tuple[KinematicsFileFormat.ValueType, bytes]

For more information, see Arm component.

abstractmethod get_3d_models(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → collections.abc.Mapping[str, viam.components.arm.Mesh][source]

Async:

Get the 3D models associated with the arm, keyed by name.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Get the arm's 3D models.
models = await my_arm.get_3d_models()

for name, mesh in models.items():
    print(name, mesh.content_type, len(mesh.mesh))

Returns:: The arm’s 3D models keyed by name. Each Mesh carries a content_type (for example "ply") and the raw mesh bytes in that format. This is distinct from get_kinematics’s third return value, which keys meshes by URDF filepath rather than by model name.
Return type:: Mapping[str, Mesh]

Note

Implementations with no models must return an empty mapping, not None.

For more information, see Arm component.

abstractmethod set_manual_mode(manual_mode: bool, enabled_for: int = 0, *, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Enter or exit manual mode for an arm that supports it.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Enter manual mode for at most 30 seconds.
await my_arm.set_manual_mode(manual_mode=True, enabled_for=30)

# Exit manual mode.
await my_arm.set_manual_mode(manual_mode=False)

Parameters:

manual_mode (bool) – Whether to enter (True) or exit (False) manual mode.
enabled_for (int) – How long to stay in manual mode, in seconds. 0 means no time limit.

For more information, see Arm component.

abstractmethod get_manual_mode(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → bool[source]

Async:

Get whether the arm is currently in manual mode.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Print whether the arm is currently in manual mode.
print(await my_arm.get_manual_mode())

Returns:: Whether the arm is in manual mode.
Return type:: bool

For more information, see Arm component.

abstractmethod get_properties(*, extra: dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → Properties[source]

Async:

Get a mapping of each optional feature to whether it is supported by this arm.

my_arm = Arm.from_robot(robot=machine, name="my_arm")

# Get the properties of the arm.
properties = await my_arm.get_properties()

Returns:: The arm’s properties; whether it supports software-enabled manual mode and whether it supports direct cartesian commands (move_to_position).
Return type:: Properties

For more information, see Arm component.

classmethod from_robot(robot: viam.robot.client.RobotClient, name: str) → Self

Get the component named name from the provided robot.

Parameters:

robot (RobotClient) – The robot
name (str) – The name of the component

Returns:

The component, if it exists on the robot

Return type:

Self

abstractmethod do_command(command: Mapping[str, ValueTypes], *, timeout: float | None = None, **kwargs) → Mapping[str, ValueTypes]

Async:

Send/Receive arbitrary commands to the Resource

command = {"cmd": "test", "data1": 500}
result = await component.do_command(command)

Parameters:: command (Mapping[str, ValueTypes]) – The command to execute
Raises:: NotImplementedError – Raised if the Resource does not support arbitrary commands
Returns:: Result of the executed command
Return type:: Mapping[str, ValueTypes]

async get_geometries(*, extra: Dict[str, Any] | None = None, timeout: float | None = None) → Sequence[viam.proto.common.Geometry]

Get all geometries associated with the component, in their current configuration, in the frame of the component.

geometries = await component.get_geometries()

if geometries:
    # Get the center of the first geometry
    print(f"Pose of the first geometry's centerpoint: {geometries[0].center}")

Returns:: The geometries associated with the Component.
Return type:: List[Geometry]

classmethod get_resource_name(name: str) → viam.proto.common.ResourceName

Get the ResourceName for this Resource with the given name

# Can be used with any resource, using an arm as an example
my_arm_name = Arm.get_resource_name("my_arm")

Parameters:: name (str) – The name of the Resource
Returns:: The ResourceName of this Resource
Return type:: ResourceName

get_operation(kwargs: Mapping[str, Any]) → viam.operations.Operation

Get the Operation associated with the currently running function.

When writing custom resources, you should get the Operation by calling this function and check to see if it’s cancelled. If the Operation is cancelled, then you can perform any necessary (terminating long running tasks, cleaning up connections, etc. ).

Parameters:: kwargs (Mapping[str, Any]) – The kwargs object containing the operation
Returns:: The operation associated with this function
Return type:: viam.operations.Operation

async close()

Safely shut down the resource and prevent further use.

Close must be idempotent. Later configuration may allow a resource to be “open” again. If a resource does not want or need a close function, it is assumed that the resource does not need to return errors when future non-Close methods are called.

await component.close()