:py:mod:`viam.components.arm.client` ==================================== .. py:module:: viam.components.arm.client Module Contents --------------- Classes ~~~~~~~ .. autoapisummary:: viam.components.arm.client.ArmClient .. py:class:: ArmClient(name: str, channel: grpclib.client.Channel) Bases: :py:obj:`viam.components.arm.Arm`, :py:obj:`viam.resource.rpc_client_base.ReconfigurableResourceRPCClientBase` gRPC client for an Arm component. Used to communicate with an existing ``Arm`` implementation over gRPC. .. py:method:: get_end_position(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) -> viam.components.arm.Pose :async: Get the current position of the end of the arm expressed as a Pose. :: my_arm = Arm.from_robot(robot=robot, name="my_arm") # Get the end position of the arm as a Pose. pos = await my_arm.get_end_position() :returns: The location and orientation of the arm described as a Pose. :rtype: Pose .. py:method:: move_to_position(pose: viam.components.arm.Pose, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Move the end of the arm to the Pose specified in ``pose``. :: my_arm = Arm.from_robot(robot=robot, 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) :param pose: The destination Pose for the arm. :type pose: Pose .. py:method:: get_joint_positions(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) -> viam.proto.component.arm.JointPositions :async: Get the JointPositions representing the current position of the arm. :: my_arm = Arm.from_robot(robot=robot, 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. :rtype: JointPositions .. py:method:: move_to_joint_positions(positions: viam.proto.component.arm.JointPositions, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Move each joint on the arm to the corresponding angle specified in ``positions``. :: my_arm = Arm.from_robot(robot=robot, name="my_arm") # Declare a list of values with your desired rotational value for each joint on # the arm. degrees = [0.0, 45.0, 0.0, 0.0, 0.0] # Declare a new JointPositions with these values. jointPos = arm.move_to_joint_positions( JointPositions(values=[0.0, 45.0, 0.0, 0.0, 0.0])) # Move each joint of the arm to the position these values specify. await my_arm.move_to_joint_positions(positions=jointPos) :param positions: The destination ``JointPositions`` for the arm. :type positions: JointPositions .. py:method:: stop(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Stop all motion of the arm. It is assumed that the arm stops immediately. :: my_arm = Arm.from_robot(robot=robot, name="my_arm") # Stop all motion of the arm. It is assumed that the arm stops immediately. await my_arm.stop() .. py:method:: is_moving(*, timeout: Optional[float] = None) -> bool :async: Get if the arm is currently moving. :: my_arm = Arm.from_robot(robot=robot, 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(my_arm.is_moving()) :returns: Whether the arm is moving. :rtype: bool .. py:method:: do_command(command: Mapping[str, Any], *, timeout: Optional[float] = None, **__) -> Mapping[str, viam.utils.ValueTypes] :async: Send/Receive arbitrary commands to the Resource :: command = {"cmd": "test", "data1": 500} result = component.do(command) :param command: The command to execute :type command: Mapping[str, ValueTypes] :raises NotImplementedError: Raised if the Resource does not support arbitrary commands :returns: Result of the executed command :rtype: Mapping[str, ValueTypes] .. py:method:: get_kinematics(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Tuple[viam.components.arm.KinematicsFileFormat.ValueType, bytes] :async: Get the kinematics information associated with the arm. :: my_arm = Arm.from_robot(robot=robot, 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: - KinematicsFileFormat.ValueType: The format of the file, either in URDF format or Viam's kinematic parameter format (spatial vector algebra). - bytes: The byte contents of the file. :rtype: Tuple[KinematicsFileFormat.ValueType, bytes] .. py:method:: get_geometries(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[viam.proto.common.Geometry] :async: 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. :rtype: List[Geometry] .. py:method:: from_robot(robot: viam.robot.client.RobotClient, name: str) -> typing_extensions.Self :classmethod: Get the component named ``name`` from the provided robot. :param robot: The robot :type robot: RobotClient :param name: The name of the component :type name: str :returns: The component, if it exists on the robot :rtype: Self .. py:method:: get_resource_name(name: str) -> viam.proto.common.ResourceName :classmethod: 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 = my_arm.get_resource_name("my_arm") :param name: The name of the Resource :type name: str .. py:method:: 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. ). :param kwargs: The kwargs object containing the operation :type kwargs: Mapping[str, Any] :returns: The operation associated with this function :rtype: viam.operations.Operation .. py:method:: close() :async: 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()