:py:mod:`viam.components.power_sensor` ====================================== .. py:module:: viam.components.power_sensor Submodules ---------- .. toctree:: :titlesonly: :maxdepth: 1 client/index.rst power_sensor/index.rst service/index.rst Package Contents ---------------- Classes ~~~~~~~ .. autoapisummary:: viam.components.power_sensor.PowerSensor .. py:class:: PowerSensor(name: str) Bases: :py:obj:`viam.components.component_base.ComponentBase` PowerSensor reports information about voltage, current and power. This acts as an abstract base class for any sensors that can provide data regarding voltage, current and/or power. This cannot be used on its own. If the ``__init__()`` function is overridden, it must call the ``super().__init__()`` function. :: from viam.components.power_sensor import PowerSensor .. py:attribute:: SUBTYPE :type: Final .. py:method:: get_voltage(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Tuple[float, bool] :abstractmethod: :async: Get the voltage reading and bool IsAC :: my_power_sensor = PowerSensor.from_robot(robot=robot, name='my_power_sensor') # Get the voltage reading from the power sensor voltage, is_ac = await my_power_sensor.get_voltage() print("The voltage is", voltage, "V, Is AC:", is_ac) :returns: voltage (volts) and bool IsAC :rtype: Tuple[float, bool] .. py:method:: get_current(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Tuple[float, bool] :abstractmethod: :async: Get the current reading and bool IsAC :: my_power_sensor = PowerSensor.from_robot(robot=robot, name='my_power_sensor') # Get the current reading from the power sensor current, is_ac = await my_power_sensor.get_current() print("The current is ", current, " A, Is AC: ", is_ac) :returns: current (amperes) and bool IsAC :rtype: Tuple[float, bool] .. py:method:: get_power(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> float :abstractmethod: :async: Get the power reading in watts :: my_power_sensor = PowerSensor.from_robot(robot=robot, name='my_power_sensor') # Get the power reading from the power sensor power = await my_power_sensor.get_power() print("The power is", power, "Watts") :returns: power in watts :rtype: float .. py:method:: get_readings(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Mapping[str, viam.utils.SensorReading] :async: Obtain the measurements/data specific to this sensor. If a sensor is not configured to have a measurement or fails to read a piece of data, it will not appear in the readings dictionary. :: my_power_sensor = PowerSensor.from_robot(robot=robot, name='my_power_sensor') # Get the readings provided by the sensor. readings = await my_power_sensor.get_readings() :returns: The readings for the PowerSensor. Can be of any type. Includes voltage in volts (float), current in amperes (float), is_ac (bool), and power in watts (float). :rtype: Mapping[str, Any] .. 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:: do_command(command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes] :abstractmethod: :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:: 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()