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.

API: Final: The API of the Resource

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 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) → 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.

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()