genericroboticarm.robo_APIs package

Subpackages

Submodules

Module contents

class genericroboticarm.robo_APIs.InteractiveRobot(start_simulating: bool = True, **kwargs)[source]

Bases: RoboInterface, InteractiveTransfer, ABC

_abc_impl = <_abc._abc_data object>
class genericroboticarm.robo_APIs.InteractiveTransfer[source]

Bases: ABC

_abc_impl = <_abc._abc_data object>
_announced_intermediate_actions: List[str] = []
announce_intermediate_actions(intermediate_actions: List[str])[source]

Tells the arm which intermediate actions the upcoming transfer command will request, so that prepare_for_input() can already do the part of them that concerns only the arm. Announcing is optional and non-binding: the actions are passed to get_labware() as usual, which has to work whether they were announced or not. :param intermediate_actions: :return:

property announced_intermediate_actions: List[str]

The intermediate actions announced for the upcoming transfer command. :return:

property available_handover_positions: List[Tuple[str, int]]

return:

property available_intermediate_actions: List[str]
List of functionalities the arm can do together with put/get labware commands,

like (un-)lidding, shaking reading barcode, etc.

Returns:

abstractmethod cancel_transfer()[source]
Returns:

abstractmethod get_labware(intermediate_actions: List[str], device: str, position: int)[source]
Parameters:

  • position

  • device

  • intermediate_actions

Returns:

abstract property number_internal_positions: int

return:

property preparable_intermediate_actions: List[str]

The subset of the available intermediate actions the arm can already work on during prepare_for_input(), provided they were announced beforehand. Fetching a lid is such an action: it concerns only the arm and can be done while the other device prepares itself. Arms that ignore announcements return nothing here. :return:

abstractmethod prepare_for_input(internal_pos: int, device: str, position: int, plate_type: str) → bool[source]
Parameters:

  • plate_type

  • plate_type

  • position

  • device

  • internal_pos

Returns:

abstractmethod prepare_for_output(internal_pos: int, device: str, position: int) → bool[source]
Parameters:

  • position

  • device

  • internal_pos

Returns:

abstractmethod put_labware(intermediate_actions: List[str], device: str, position: int)[source]
Parameters:

  • position

  • device

  • intermediate_actions

Returns:

class genericroboticarm.robo_APIs.RoboInterface(start_simulating: bool = True, **kwargs)[source]

Bases: ABC

_abc_impl = <_abc._abc_data object>
_deferred_failure: BaseException | None
_deferred_tail: Callable[[], None] | None
abstract property current_coordinates: Dict[str, float]

return:

current_position: str | None = None
property currently_gripping_plate: bool

Whether the gripper currently holds a plate. Robots that cannot sense their gripper report False, so the guards against picking with an occupied gripper do not fire for them. Subclasses that can tell override this. :return:

defer(tail_task: Callable[[], None]) → None[source]

Registers work that may be executed after the running command has reported success, e.g. storing a lid away once the robot is clear of the device it just served. The robot stays reserved until the tail task is done, so the next command has to wait for it, but the client and the served device are released early. Only one tail task can be pending at a time. :param tail_task: the work to be done once the current command returned :return:

end_connection(**kwargs)[source]

Is executed when the server stops :return:

abstractmethod classmethod get_name() → str[source]

The name will be used as parameter in command line startup (-r), as sila server name and to save the position graph. :return: the name

abstractmethod classmethod get_used_cli_args() → dict[str, str][source]

Defines the arguments that are forwarded from the command line to the robots constructor. :return: a dictionary of type [constructor parameter name, command line argument name]

graph_dir: Path | None = None
abstractmethod grip_close(**kwargs)[source]
Returns:

abstractmethod grip_open(**kwargs)[source]
Returns:

abstractmethod init_connection(**kwargs)[source]

Sets up the hardware connection :return:

abstract property joint_names: list[str]

Returns a list of names of the individual coordinates used by the robot. For example [x, y, z, roll, pitch, grip] or [j1, j2, j3, j4, j5] :return:

abstractmethod move_relative(movements: List[Tuple[str, float]], **kwargs)[source]
Parameters:

movements

Returns:

move_straight_to_position(identifier: str, offset: Dict[str, float] | None = None)[source]

Moves the robot straight to the specified position, i.e. queries its coordinates, adds the offset and call move_to_coordinates() on the result. :param offset: :param identifier: :return:

abstractmethod move_to_coordinates(coords: Dict[str, float], **kwargs) → None[source]
Parameters:

coords

Returns:

move_to_nearest_known_position(offset: Dict[str, float] | None = None)[source]
Returns:

move_to_position(target_position: str, offset: Dict[str, float] | None = None)[source]
Parameters:

  • offset

  • target_position

Returns:

property name: str
next_positions: List[str]
pick_at_position(identifier: str, offset: Dict[str, float] | None = None)[source]

Opens the gripper, moves to a specified location and closes the gripper there :param identifier: Position identifier :param offset: :return:

pick_from_device(device: str, pos: int, offset: Dict[str, float] | None = None)[source]
Parameters:

  • device

  • pos

  • offset

Returns:

place_at_device(device: str, pos: int, offset: Dict[str, float] | None = None, plate_type: str = 'plate_type')[source]
Parameters:

  • plate_type

  • device

  • pos

  • offset

Returns:

place_at_position(identifier: str, offset: Dict[str, float] | None = None)[source]

Opens the gripper, moves to a specified location and opens the gripper there :param identifier: Position identifier :param offset: :return:

pop_deferred() → Callable[[], None] | None[source]

Returns the registered tail task, if any, and forgets about it. :return: the tail task or None

report_deferred_failure(error: BaseException)[source]

Remembers that a tail task failed. Since its command has already reported success, the failure can only be handed to the next command touching the robot. :param error: :return:

run_custom_command(cmd: str) → str[source]

Runs a custom command on the hardware. The implementation for a specific hardware might look very different and the response must be a string. Be default returns ‘Not Implemented’. Use on your own risk. :param cmd: :return:

set_acceleration(new_acceleration: float, **kwargs)[source]
Parameters:

new_acceleration

Returns:

set_metrik(metrik: Callable[[Dict[str, float], Dict[str, float]], float])[source]

Sets the way :param metrik: :return:

set_speed(new_speed: float)[source]

Set the speed :param new_speed: :return:

site_to_position_identifier(device: str, slot: int) → str[source]
stop_moving()[source]

Immediately(Or as quickly as possible) stops all movements :return:

take_deferred_failure() → BaseException | None[source]

Returns the failure of the last tail task, if any, and forgets about it. :return: the error or None

genericroboticarm.robo_APIs.collect_robo_implementations(package: str = 'genericroboticarm.robo_APIs') → set[type[RoboInterface]][source]

Recursively find all subclasses of RoboInterface in a package.

Parameters:

package – Dotted path of the package

Returns:

list of RoboInterface subclasses

genericroboticarm.robo_APIs.get_arm_impl(impl_str: str) → RoboInterface | None[source]

Dynamically imports the specified robotic arm implementation class.

Parameters:

impl_str (str) – The robotic arm implementation class to use, formatted as <module>:<class>