:py:mod:`viam.components.encoder.client`
========================================

.. py:module:: viam.components.encoder.client


Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   viam.components.encoder.client.EncoderClient




.. py:class:: EncoderClient(name: str, channel: grpclib.client.Channel)


   Bases: :py:obj:`viam.components.encoder.encoder.Encoder`, :py:obj:`viam.resource.rpc_client_base.ReconfigurableResourceRPCClientBase`

   gRPC client for the Encoder component.

   .. py:method:: reset_position(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__)
      :async:

      Set the current position to be the new zero (home) position.

      ::

          my_encoder = Encoder.from_robot(robot=robot, name='my_encoder')

          # Reset the zero position of the encoder.
          await my_encoder.reset_position()



   .. py:method:: get_position(position_type: Optional[viam.proto.component.encoder.PositionType.ValueType] = None, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) -> Tuple[float, viam.proto.component.encoder.PositionType.ValueType]
      :async:

      Report the position of the encoder.
      The value returned is the current position in terms of it's ``position_type``.
      The position will be either in relative units (ticks away from a zero position) for
      ``PositionType.TICKS`` or absolute units (degrees along a circle) for ``PositionType.DEGREES``.

      ::

          my_encoder = Encoder.from_robot(robot=robot, name='my_encoder')

          # Get the position of the encoder in ticks
          position = await my_encoder.get_position(encoder.PositionTypeTicks)
          print("The encoder position is currently ", position[0], position[1])

      :param position_type: The desired output type of the position
      :type position_type: PositionType.ValueType

      :returns:

                A tuple containing two values; the first [0] the Position of the encoder which can either be
                    ticks since last zeroing for a relative encoder or degrees for an absolute encoder, and the second [1] the type of
                    position the encoder returns (ticks or degrees).
      :rtype: Tuple[float, PositionType]


   .. py:method:: get_properties(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **__) -> viam.components.encoder.encoder.Encoder.Properties
      :async:

      Return a dictionary of the types of position reporting this encoder supports

      ::

          my_encoder = Encoder.from_robot(robot=robot, name='my_encoder')

          # Get whether the encoder returns position in ticks or degrees.
          properties = await my_encoder.get_properties()

      :returns: Map of position types to supported status.
      :rtype: Encoder.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()