opentrons 8.6.0__py3-none-any.whl

opentrons/hardware_control/scripts/gripper_control.py

@@ -0,0 +1,208 @@
+import sys
+import argparse
+import datetime
+import enum
+
+sys.path.append("/opt/opentrons-robot-server")
+
+from opentrons.hardware_control.thread_manager import ThreadManager  # noqa: E402
+from opentrons.hardware_control.ot3api import OT3API  # noqa: E402
+from opentrons.hardware_control.types import Axis, OT3Mount  # noqa: E402
+from opentrons.hardware_control import HardwareControlAPI  # noqa: E402
+from opentrons.types import Point  # noqa: E402
+from opentrons_shared_data.deck import load as load_deck_def  # noqa: E402
+
+
+class InvalidInput(Exception):
+    """Invalid input exception."""
+
+    pass
+
+
+VERSION = 2.0
+MOUNT = OT3Mount.GRIPPER
+deck_def = load_deck_def("ot3_standard", version=3)
+# Offset of the center of the gripper jaw to the desired location
+GRIPPER_OFFSET = Point(0.0, 1.0, 0.0)
+AVAILABLE_SLOTS = [1, 3, 4, 9, 10, 12]
+
+
+class GripperState(enum.Enum):
+    UNGRIPPING = enum.auto()
+    GRIPPING = enum.auto()
+    Z_HOMED = enum.auto()
+    Z_LOWERED = enum.auto()
+
+
+VERSION = 2.0
+MOUNT = OT3Mount.GRIPPER
+deck_def = load_deck_def("ot3_standard", version=3)
+# Offset of the center of the gripper jaw to the desired location
+GRIPPER_OFFSET = Point(0.0, 1.0, 0.0)
+AVAILABLE_SLOTS = [1, 3, 4, 9, 10, 12]
+
+
+def prompt_int_input(prompt_name: str) -> int:
+    """Prompt to choose a member of the enum.
+
+    Args:
+        output_func: Function to output text to user.
+        get_user_input: Function to get user input.
+        enum_type: an enum type
+
+    Returns:
+        The choice.
+
+    """
+    try:
+        return int(input(f"{prompt_name}: "))
+    except (ValueError, IndexError) as e:
+        raise InvalidInput(e)
+
+
+def prompt_float_input(prompt_name: str) -> float:
+    """Prompt for a float."""
+    try:
+        return float(input(f"{prompt_name}: "))
+    except (ValueError, IndexError) as e:
+        raise InvalidInput(e)
+
+
+def prompt_bool_input(prompt_name: str) -> float:
+    """Prompt for a bool."""
+    try:
+        return {"true": True, "false": False}[input(f"{prompt_name}: ").lower()]
+    except (ValueError, IndexError) as e:
+        raise InvalidInput(e)
+
+
+def get_slot_center_in_deck_coord(slot_id: int) -> Point:
+    corner = Point(*deck_def["locations"]["orderedSlots"][slot_id - 1]["position"])
+    return Point(corner.x + 128.0 / 2, corner.y + 86.0 / 2, corner.z)
+
+
+def build_api() -> ThreadManager[HardwareControlAPI]:
+    api = ThreadManager(OT3API.build_hardware_controller)
+    api.managed_thread_ready_blocking()
+    return api
+
+
+def print_current_state(
+    api: ThreadManager[HardwareControlAPI],
+    cycle_index: int,
+    slot: int,
+    jaw_state: GripperState,
+) -> None:
+    """
+    1. timestamp
+    2. current cycle
+    3. current slot
+    4. gripper position (X, Y, Z_G)
+    5. gripper state: open/closed
+    6. encoder positions (X, Y, G)
+    """
+    pos = api.sync.current_position_ot3(OT3Mount.GRIPPER)
+    gripper_loc = (pos[Axis.X], pos[Axis.Y], pos[Axis.Z_G])
+
+    enc_pos = api.sync._encoder_position
+    enc_loc = (enc_pos[Axis.X], enc_pos[Axis.Y], enc_pos[Axis.G])
+    print(
+        f"{datetime.datetime.now()}, {cycle_index}, {slot}, "
+        f"{gripper_loc}, {jaw_state}, {enc_loc}\n"
+    )
+
+
+def add_args(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    parser.add_argument(
+        "--origin",
+        type=int,
+        required=False,
+        default=1,
+        help="select slot from 1, 3, 4, 9, 10, 12",
+    )
+    parser.add_argument(
+        "--grip_force",
+        type=float,
+        required=False,
+        default=20,
+        help="grip force in Newton",
+    )
+    parser.add_argument(
+        "--grip_height",
+        type=float,
+        required=False,
+        default=25,
+        help="grip height in mm",
+    )
+    parser.add_argument(
+        "--repeats",
+        type=int,
+        required=False,
+        default=0,
+        help="how many times to repeat the test",
+    )
+    return parser
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Gripper control script.")
+    add_args(parser)
+    args = parser.parse_args()
+
+    hc_api = build_api()
+
+    from_slot = args.origin
+    grip_force = args.grip_force
+    grip_height = args.grip_height
+    repeats = args.repeats
+
+    api = hc_api.sync
+    api.home()
+    homed_pos = api.gantry_position(MOUNT)
+
+    from_slot_loc = get_slot_center_in_deck_coord(from_slot) + GRIPPER_OFFSET
+
+    AVAILABLE_SLOTS.remove(from_slot)
+
+    for cycle in range(repeats + 1):
+        for slot_index, to_slot in enumerate(AVAILABLE_SLOTS):
+            to_slot_loc = get_slot_center_in_deck_coord(to_slot) + GRIPPER_OFFSET
+            if cycle == 0 and slot_index == 0:
+                # move to pick up position at origin slot
+                api.move_to(MOUNT, from_slot_loc._replace(z=homed_pos.z))
+                print_current_state(hc_api, cycle, from_slot, GripperState.Z_HOMED)
+                api.move_to(MOUNT, from_slot_loc._replace(z=grip_height))
+                print_current_state(hc_api, cycle, from_slot, GripperState.Z_LOWERED)
+
+            api.grip(grip_force)
+            api.delay(1)
+            print_current_state(hc_api, cycle, from_slot, GripperState.GRIPPING)
+
+            # move to drop off position at destination slot
+            api.move_to(MOUNT, from_slot_loc._replace(z=homed_pos.z))
+            print_current_state(hc_api, cycle, from_slot, GripperState.Z_HOMED)
+            api.move_to(MOUNT, to_slot_loc._replace(z=homed_pos.z))
+            print_current_state(hc_api, cycle, to_slot, GripperState.Z_HOMED)
+            api.move_to(MOUNT, to_slot_loc._replace(z=grip_height))
+            print_current_state(hc_api, cycle, to_slot, GripperState.Z_LOWERED)
+
+            api.ungrip()
+            api.delay(1)
+            print_current_state(hc_api, cycle, to_slot, GripperState.UNGRIPPING)
+
+            api.grip(grip_force)
+            api.delay(1.0)
+            print_current_state(hc_api, cycle, to_slot, GripperState.GRIPPING)
+
+            api.move_to(MOUNT, to_slot_loc._replace(z=homed_pos.z))
+            print_current_state(hc_api, cycle, to_slot, GripperState.Z_HOMED)
+            api.move_to(MOUNT, from_slot_loc._replace(z=homed_pos.z))
+            print_current_state(hc_api, cycle, from_slot, GripperState.Z_HOMED)
+            api.move_to(MOUNT, from_slot_loc._replace(z=grip_height))
+            print_current_state(hc_api, cycle, from_slot, GripperState.Z_LOWERED)
+
+            api.ungrip()
+            api.delay(1.0)
+            print_current_state(hc_api, cycle, from_slot, GripperState.UNGRIPPING)
+
+    api.home()

opentrons/hardware_control/scripts/ot3gripper

@@ -0,0 +1,7 @@
+#!/bin/sh
+# Wrapper script to run the hardware control ot3gripper with correct
+# environment variables. Should be installed to path; run with
+# ot3gripper
+orig=$(pwd)
+cd /opt/opentrons-robot-server
+OT_API_FF_enableOT3HardwareController="true" RUNNING_ON_VERDIN=1 OT_SYSTEM_VERSION="0.0.0" python3 -m opentrons.hardware_control.scripts.gripper_control && cd ${orig} || cd ${orig}

opentrons/hardware_control/scripts/ot3repl

@@ -0,0 +1,7 @@
+#!/bin/sh
+# Wrapper script to run the hardware control repl with correct
+# environment variables. Should be installed to path; run with
+# ot3repl
+orig=$(pwd)
+cd /opt/opentrons-robot-server
+OT_API_FF_enableOT3HardwareController="true" RUNNING_ON_VERDIN=1 OT_SYSTEM_VERSION="0.0.0" python3 -m opentrons.hardware_control.scripts.repl && cd ${orig} || cd ${orig}

opentrons/hardware_control/scripts/repl.py

@@ -0,0 +1,187 @@
+"""opentrons.hardware_control.scripts.repl - cli for hc api
+
+Running this script will create and spin up a hardware controller
+and expose it to a python commandline.
+"""
+
+import os
+from functools import wraps
+import asyncio
+import logging
+from logging.config import dictConfig
+from opentrons.hardware_control.api import API
+from opentrons.hardware_control.ot3api import OT3API
+from opentrons.hardware_control.types import HardwareFeatureFlags
+
+update_firmware = True
+has_robot_server = True
+if os.environ.get("OPENTRONS_SIMULATION"):
+    print("Running with simulators")
+    has_robot_server = False
+if os.environ.get("OT2", None):
+    print(
+        '"OT2" env var detected, running with OT2 HC. '
+        "If you dont want this, remove the OT2 env var"
+    )
+    os.environ["OT_API_FF_enableOT3HardwareController"] = "false"
+else:
+    print("Running with OT3 HC. If you dont want this, set an env var named 'OT2'")
+    os.environ["OT_API_FF_enableOT3HardwareController"] = "true"
+    if os.environ.get("OT3_DISABLE_FW_UPDATES"):
+        update_firmware = False
+        print("OT3 firmware updates are disabled")
+
+from code import interact  # noqa: E402
+from subprocess import run  # noqa: E402
+from typing import Union, Type, Any  # noqa: E402
+
+from opentrons.types import Mount, Point  # noqa: E402
+from opentrons.config import feature_flags as ff  # noqa: E402
+from opentrons.hardware_control.modules.types import ModuleType  # noqa: E402
+from opentrons.hardware_control.types import (  # noqa: E402
+    Axis,
+    OT3Mount,
+    SubSystem,
+    GripperProbe,
+    CriticalPoint,
+)
+from opentrons.hardware_control.ot3_calibration import (  # noqa: E402
+    calibrate_pipette,
+    calibrate_belts,
+    delete_belt_calibration_data,
+    calibrate_gripper_jaw,
+    calibrate_module,
+    find_calibration_structure_height,
+    find_edge_binary,
+    CalibrationMethod,
+    find_axis_center,
+    gripper_pin_offsets_mean,
+)
+from opentrons.hardware_control.thread_manager import ThreadManager  # noqa: E402
+
+
+log = logging.getLogger(__name__)
+
+LOG_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "basic": {"format": "%(asctime)s %(name)s %(levelname)s %(message)s"}
+    },
+    "handlers": {
+        "file_handler": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "formatter": "basic",
+            "filename": "/var/log/repl.log",
+            "maxBytes": 5000000,
+            "level": logging.INFO,
+            "backupCount": 3,
+        },
+    },
+    "loggers": {
+        "": {
+            "handlers": ["file_handler"],
+            "level": logging.INFO,
+        },
+    },
+}
+
+if ff.enable_ot3_hardware_controller():
+
+    HCApi: Union[Type[OT3API], Type[API]] = OT3API
+
+    def build_thread_manager() -> ThreadManager[Union[API, OT3API]]:
+        return ThreadManager(
+            OT3API.build_hardware_controller,
+            use_usb_bus=ff.rear_panel_integration(),
+            update_firmware=update_firmware,
+            feature_flags=HardwareFeatureFlags.build_from_ff(),
+        )
+
+    def wrap_async_util_fn(fn: Any, *bind_args: Any, **bind_kwargs: Any) -> Any:
+        @wraps(fn)
+        def synchronizer(*args: Any, **kwargs: Any) -> Any:
+            return asyncio.new_event_loop().run_until_complete(
+                fn(*bind_args, *args, **bind_kwargs, **kwargs)
+            )
+
+        return synchronizer
+
+else:
+
+    HCApi = API
+
+    def build_thread_manager() -> ThreadManager[Union[API, OT3API]]:
+        return ThreadManager(
+            API.build_hardware_controller,
+            feature_flags=HardwareFeatureFlags.build_from_ff(),
+        )
+
+
+logging.basicConfig(level=logging.INFO)
+
+
+def stop_server() -> None:
+    run(["systemctl", "stop", "opentrons-robot-server"])
+
+
+def build_api() -> ThreadManager[Union[API, OT3API]]:
+    # NOTE: We are using StreamHandler so when the hw controller is
+    # being built we can log firmware update progress to stdout.
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    logging.getLogger().addHandler(stream_handler)
+    tm = build_thread_manager()
+    logging.getLogger().removeHandler(stream_handler)
+    tm.managed_thread_ready_blocking()
+
+    if update_firmware:
+
+        async def _do_update() -> None:
+            async for update in tm.update_firmware():
+                print(f"Update: {update.subsystem.name}: {update.progress}%")
+
+        asyncio.run(_do_update())
+
+    return tm
+
+
+def do_interact(api: ThreadManager[Union[API, OT3API]]) -> None:
+    interact(
+        banner=(
+            "Hardware Control API REPL\nCall methods on api like "
+            "api.move_to(Mount.RIGHT, Point(400, 400, 500))"
+        ),
+        local={
+            "api": api.sync,
+            "Mount": Mount,
+            "Point": Point,
+            "Axis": Axis,
+            "OT3Mount": OT3Mount,
+            "SubSystem": SubSystem,
+            "GripperProbe": GripperProbe,
+            "ModuleType": ModuleType,
+            "find_edge": wrap_async_util_fn(find_edge_binary, api),
+            "find_calibration_structure_height": wrap_async_util_fn(
+                find_calibration_structure_height, api
+            ),
+            "calibrate_pipette": wrap_async_util_fn(calibrate_pipette, api),
+            "calibrate_belts": wrap_async_util_fn(calibrate_belts, api),
+            "delete_belt_calibration_data": delete_belt_calibration_data,
+            "calibrate_gripper": wrap_async_util_fn(calibrate_gripper_jaw, api),
+            "calibrate_module": wrap_async_util_fn(calibrate_module, api),
+            "gripper_pin_offsets_mean": gripper_pin_offsets_mean,
+            "CalibrationMethod": CalibrationMethod,
+            "find_axis_center": wrap_async_util_fn(find_axis_center, api),
+            "CriticalPoint": CriticalPoint,
+        },
+    )
+
+
+if __name__ == "__main__":
+    dictConfig(LOG_CONFIG)
+    if has_robot_server:
+        stop_server()
+    api_tm = build_api()
+    do_interact(api_tm)
+    api_tm.clean_up()

opentrons/hardware_control/scripts/tc_control.py

@@ -0,0 +1,97 @@
+from serial import Serial  # type: ignore[import-untyped]
+import asyncio
+import subprocess
+from typing import Any
+
+_READ_ALL = "readall"
+_READ_LINE = "read"
+_DONE = "done"
+_MOVE_SEAL = "ms"
+_MOVE_LID = "ml"
+
+gcode_shortcuts = {
+    "status": "M119",
+    _MOVE_SEAL: "M241.D",  # move seal motor
+    _MOVE_LID: "M240.D",  # move lid stepper motor
+    "ol": "M126",  # open lid
+    "cl": "M127",  # close lid
+    "sw": "M901.D",  # status of all switches
+    "lt": "M141.D",  # get lid temperature
+    "pt": "M105.D",  # get plate temperature
+}
+
+
+async def message_read(dev: Serial) -> Any:
+    response = dev.readline().decode()
+    while not response:
+        await asyncio.sleep(1)
+        response = dev.readline().decode()
+    return response
+
+
+async def message_return(dev: Serial) -> Any:
+    try:
+        response = await asyncio.wait_for(message_read(dev), timeout=20)
+        return response
+    except asyncio.exceptions.TimeoutError:
+        print("response timed out.")
+        return ""
+
+
+async def handle_gcode_shortcut(dev: Serial, command: str) -> None:
+    # handle debugging commands that require followup
+    if command == _MOVE_SEAL:
+        distance = input("enter distance in steps => ")
+        dev.write(
+            f"{gcode_shortcuts[command]} {distance}\n".encode()
+        )  # (+) -> retract, (-) -> engage
+        print(await message_return(dev))
+    elif command == _MOVE_LID:
+        distance = input(
+            "enter angular distance in degrees => "
+        )  # (+) -> open, (-) -> close
+        dev.write(f"{gcode_shortcuts[command]} {distance}\n".encode())
+        print(await message_return(dev))
+    # everything else
+    else:
+        dev.write(f"{gcode_shortcuts[command]}\n".encode())
+        print(await message_return(dev))
+
+
+async def comms_loop(dev: Serial) -> bool:
+    _exit = False
+    command = input("\n>>> ")
+    if command == _READ_ALL:
+        print(dev.readlines())
+    elif command == _READ_LINE:
+        print(dev.readline())
+    elif command == _DONE:
+        _exit = True
+    elif command in gcode_shortcuts:
+        await handle_gcode_shortcut(dev, command)
+    else:
+        try:
+            dev.write(f"{command}\n".encode())
+            print(await message_return(dev))
+        except TypeError:
+            print("Invalid input.")
+    return _exit
+
+
+async def _main() -> None:
+    tc_name = (
+        subprocess.check_output(["find", "/dev/", "-name", "*thermocycler*"])
+        .decode()
+        .strip()
+    )
+    if not tc_name:
+        print("Thermocycler not found. Exiting.")
+        return
+    dev = Serial(f"{tc_name}", 9600, timeout=2)
+    _exit = False
+    while not _exit:
+        _exit = await comms_loop(dev)
+
+
+if __name__ == "__main__":
+    asyncio.run(_main())