viam.components.arm.client

Classes

ArmClient

gRPC client for an Arm component.

Module Contents

class viam.components.arm.client.ArmClient(name: str, channel: grpclib.client.Channel)[source]

Bases: viam.components.arm.Arm, viam.resource.rpc_client_base.ReconfigurableResourceRPCClientBase

gRPC client for an Arm component.

Used to communicate with an existing Arm implementation over gRPC.

channel

client

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

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.

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

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.

async get_joint_positions(*, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → viam.proto.component.arm.JointPositions[source]

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.

async move_to_joint_positions(positions: viam.proto.component.arm.JointPositions, *, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

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.

async move_through_joint_positions(positions: List[viam.proto.component.arm.JointPositions], options: viam.proto.component.arm.MoveOptions | None = None, *, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

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.

async move_through_joint_positions_streamed(batches: AsyncIterator[List[viam.components.arm.Arm.TrajectoryPoint]], *, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → AsyncIterator[viam.components.arm.Arm.TrajectoryUpdate][source]

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]

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

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.

async is_moving(*, timeout: float | None = None, **kwargs) → bool[source]

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.

async do_command(command: Mapping[str, Any], *, timeout: float | None = None, **kwargs) → Mapping[str, viam.utils.ValueTypes][source]

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_status(*, timeout: float | None = None, **kwargs) → Mapping[str, viam.utils.ValueTypes][source]

Get the current status of the component as a dictionary.

status = await component.get_status()

Returns:: The status of the component
Return type:: Mapping[str, ValueTypes]

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

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.

async get_3d_models(*, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → Mapping[str, viam.proto.common.Mesh][source]

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.

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

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]

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

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.

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

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.

async get_properties(*, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → viam.components.arm.Arm.Properties[source]

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

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