:py:mod:`viam.components.base.client` ===================================== .. py:module:: viam.components.base.client Module Contents --------------- Classes ~~~~~~~ .. autoapisummary:: viam.components.base.client.BaseClient .. py:class:: BaseClient(name: str, channel: grpclib.client.Channel) Bases: :py:obj:`viam.components.base.Base`, :py:obj:`viam.resource.rpc_client_base.ReconfigurableResourceRPCClientBase` gRPC client for the Base component. .. py:method:: move_straight(distance: int, velocity: float, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Move the base in a straight line the given ``distance``, expressed in millimeters, at the given ``velocity``, expressed in millimeters per second. When ``distance`` or ``velocity`` is 0, the base will stop. This method blocks until completed or cancelled. :: my_base = Base.from_robot(robot=robot, name="my_base") # Move the base 40 mm at a velocity of 90 mm/s, forward. await my_base.move_straight(distance=40, velocity=90) # Move the base 40 mm at a velocity of -90 mm/s, backward. await my_base.move_straight(distance=40, velocity=-90) :param distance: The distance (in millimeters) to move. Negative implies backwards. :type distance: int :param velocity: The velocity (in millimeters per second) to move. Negative implies backwards. :type velocity: float .. py:method:: spin(angle: float, velocity: float, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Spin the base in place ``angle`` degrees, at the given angular ``velocity``, expressed in degrees per second. When ``velocity`` is 0, the base will stop. This method blocks until completed or cancelled. :: my_base = Base.from_robot(robot=robot, name="my_base") # Spin the base 10 degrees at an angular velocity of 15 deg/sec. await my_base.spin(angle=10, velocity=15) :param angle: The angle (in degrees) to spin. :type angle: float :param velocity: The angular velocity (in degrees per second) to spin. Given a positive angle and a positive velocity, the base will turn to the left. :type velocity: float .. py:method:: set_power(linear: viam.components.base.Vector3, angular: viam.components.base.Vector3, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Set the linear and angular velocity of the Base When ``linear`` is 0, the the base will spin. When ``angular`` is 0, the the base will move in a straight line. When both ``linear`` and ``angular`` are 0, the base will stop. When ``linear`` and ``angular`` are both nonzero, the base will move in an arc, with a tighter radius if angular power is greater than linear power. :: my_base = Base.from_robot(robot=robot, name="my_base") # Make your wheeled base move forward. Set linear power to 75%. print("move forward") await my_base.set_power( linear=Vector3(x=0, y=-.75, z=0), angular=Vector3(x=0, y=0, z=0)) # Make your wheeled base move backward. Set linear power to -100%. print("move backward") await my_base.set_power( linear=Vector3(x=0, y=-1.0, z=0), angular=Vector3(x=0, y=0, z=0)) # Make your wheeled base spin left. Set angular power to 100%. print("spin left") await my_base.set_power( linear=Vector3(x=0, y=0, z=0), angular=Vector3(x=0, y=0, z=1)) # Make your wheeled base spin right. Set angular power to -75%. print("spin right") await my_base.set_power( linear=Vector3(x=0, y=0, z=0), angular=Vector3(x=0, y=0, z=-.75)) :param linear: The linear component. Only the Y component is used for wheeled base. Positive implies forwards. :type linear: Vector3 :param angular: The angular component. Only the Z component is used for wheeled base. Positive turns left; negative turns right. :type angular: Vector3 .. py:method:: set_velocity(linear: viam.components.base.Vector3, angular: viam.components.base.Vector3, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Set the linear and angular velocities of the base. :: my_base = Base.from_robot(robot=robot, name="my_base") # Set the linear velocity to 50 mm/sec and the angular velocity to # 15 degree/sec. await my_base.set_velocity( linear=Vector3(x=0, y=50, z=0), angular=Vector3(x=0, y=0, z=15)) :param linear: Velocity in mm/sec :type linear: Vector3 :param angular: Velocity in deg/sec :type angular: Vector3 .. py:method:: stop(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) :async: Stop the base. :: my_base = Base.from_robot(robot=robot, name="my_base") # Move the base forward 10 mm at a velocity of 50 mm/s. await my_base.move_straight(distance=10, velocity=50) # Stop the base. await my_base.stop() .. py:method:: is_moving(*, timeout: Optional[float] = None, **__) -> bool :async: Get if the base is currently moving. :: my_base = Base.from_robot(robot=robot, name="my_base") # Check whether the base is currently moving. moving = await my_base.is_moving() print('Moving: ', moving) :returns: Whether the base is moving. :rtype: bool .. py:method:: get_properties(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) -> viam.components.base.Base.Properties :async: Get the base width and turning radius :: my_base = Base.from_robot(robot=robot, name="my_base") # Get the width and turning radius of the base properties = await my_base.get_properties() # Get the width print(f"Width of base: {properties.width_meters}") # Get the turning radius print(f"Turning radius of base: {properties.turning_radius_meters}") # Get the wheel circumference print(f"Wheel circumference of base: {properties.wheel_circumference_meters}") :returns: The properties of the base :rtype: Properties .. py:method:: do_command(command: Mapping[str, viam.utils.ValueTypes], *, 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_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 :returns: The ResourceName of this Resource :rtype: ResourceName .. 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()