viam.components.gantry.gantry
=============================
.. py:module:: viam.components.gantry.gantry
Classes
-------
.. autoapisummary::
viam.components.gantry.gantry.Gantry
Module Contents
---------------
.. py:class:: Gantry(name: str, *, logger: Optional[logging.Logger] = None)
Bases: :py:obj:`viam.components.component_base.ComponentBase`
Gantry represents a physical Gantry and can be used for controlling gantries of N axes.
This acts as an abstract base class for any drivers representing specific
gantry implementations. This cannot be used on its own. If the ``__init__()`` function is
overridden, it must call the ``super().__init__()`` function.
::
from viam.components.gantry import Gantry
For more information, see `Gantry component `_.
.. py:attribute:: API
:type: Final
The API of the Resource
.. py:method:: get_position(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[float]
:abstractmethod:
:async:
Get the positions of the axes of the gantry in millimeters.
::
my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
# Get the current positions of the axes of the gantry in millimeters.
positions = await my_gantry.get_position()
:returns: A list of the position of the axes of the gantry in millimeters.
:rtype: List[float]
For more information, see `Gantry component `_.
.. py:method:: move_to_position(positions: List[float], speeds: List[float], *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs)
:abstractmethod:
:async:
Move the axes of the gantry to the desired positions (mm) at the requested speeds (mm/sec).
::
my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
# Create a list of positions for the axes of the gantry to move to. Assume in
# this example that the gantry is multi-axis, with 3 axes.
examplePositions = [1, 2, 3]
exampleSpeeds = [3, 9, 12]
# Move the axes of the gantry to the positions specified.
await my_gantry.move_to_position(
positions=examplePositions, speeds=exampleSpeeds)
:param positions: A list of positions for the axes of the gantry to move to, in millimeters.
:type positions: List[float]
:param speeds: A list of speeds in millimeters per second for the gantry to move at respective to each axis.
:type speeds: List[float]
For more information, see `Gantry component `_.
.. py:method:: home(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> bool
:abstractmethod:
:async:
Run the homing sequence of the gantry to re-calibrate the axes with respect to the limit switches.
::
my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
await my_gantry.home()
:returns: Whether the gantry has run the homing sequence successfully.
:rtype: bool
For more information, see `Gantry component `_.
.. py:method:: get_lengths(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[float]
:abstractmethod:
:async:
Get the lengths of the axes of the gantry in millimeters.
::
my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
# Get the lengths of the axes of the gantry in millimeters.
lengths_mm = await my_gantry.get_lengths()
:returns: A list of the lengths of the axes of the gantry in millimeters.
:rtype: List[float]
For more information, see `Gantry component `_.
.. py:method:: stop(*, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs)
:abstractmethod:
:async:
Stop all motion of the gantry. It is assumed that the gantry stops immediately.
::
my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
# Stop all motion of the gantry. It is assumed that the gantry stops
# immediately.
await my_gantry.stop()
For more information, see `Gantry component `_.
.. py:method:: is_moving() -> bool
:abstractmethod:
:async:
Get if the gantry is currently moving.
::
my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
# Stop all motion of the gantry. It is assumed that the
# gantry stops immediately.
await my_gantry.stop()
# Print if the gantry is currently moving.
print(await my_gantry.is_moving())
:returns: Whether the gantry is moving.
:rtype: bool
For more information, see `Gantry component `_.
.. 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 = await component.do_command(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 = 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()