opentrons 8.7.0a1__py3-none-any.whl → 8.7.0a2__py3-none-any.whl

opentrons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '8.7.0a1'
-__version_tuple__ = version_tuple = (8, 7, 0, 'a1')
+__version__ = version = '8.7.0a2'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a2')
 
 __commit_id__ = commit_id = None

opentrons/drivers/thermocycler/abstract.py

@@ -55,6 +55,7 @@ class AbstractThermocyclerDriver(ABC):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Send set plate temperature command"""
         ...

opentrons/drivers/thermocycler/driver.py

@@ -226,6 +226,7 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Send set plate temperature command"""
         temp = min(BLOCK_TARGET_MAX, max(BLOCK_TARGET_MIN, temp))
@@ -343,10 +344,38 @@ class ThermocyclerDriverV2(ThermocyclerDriver):
         """
         super().__init__(connection)
 
-    async def set_ramp_rate(self, ramp_rate: float) -> None:
-        """Send a set ramp rate command"""
-        # This command is fully unsupported on TC Gen2
-        return None
+    async def set_plate_temperature(
+        self,
+        temp: float,
+        hold_time: Optional[float] = None,
+        volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
+    ) -> None:
+        """Send set plate temperature command"""
+        temp = min(BLOCK_TARGET_MAX, max(BLOCK_TARGET_MIN, temp))
+
+        c = (
+            CommandBuilder(terminator=TC_COMMAND_TERMINATOR)
+            .add_gcode(gcode=GCODE.SET_PLATE_TEMP)
+            .add_float(
+                prefix="S", value=temp, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+        )
+        if hold_time is not None:
+            c = c.add_float(
+                prefix="H", value=hold_time, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+        if volume is not None:
+            c = c.add_float(
+                prefix="V", value=volume, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+
+        if ramp_rate is not None:
+            c = c.add_float(
+                prefix="R", value=ramp_rate, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+
+        await self._connection.send_command(command=c, retries=DEFAULT_COMMAND_RETRIES)
 
     async def get_device_info(self) -> Dict[str, str]:
         """Send get device info command"""

opentrons/drivers/thermocycler/simulator.py

@@ -67,10 +67,12 @@ class SimulatingDriver(AbstractThermocyclerDriver):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         self._plate_temperature.target = temp
         self._plate_temperature.current = temp
         self._plate_temperature.hold = 0
+        self._ramp_rate = ramp_rate
 
     @ensure_yield
     async def get_plate_temperature(self) -> PlateTemperature:

opentrons/hardware_control/api.py

@@ -44,6 +44,7 @@ from .execution_manager import ExecutionManagerProvider
 from .pause_manager import PauseManager
 from .module_control import AttachedModulesControl
 from .types import (
+    AsynchronousModuleErrorNotification,
     Axis,
     CriticalPoint,
     DoorState,
@@ -51,6 +52,7 @@ from .types import (
     ErrorMessageNotification,
     HardwareEventHandler,
     HardwareAction,
+    HardwareEvent,
     MotionChecks,
     PauseType,
     StatusBarState,
@@ -167,6 +169,18 @@ class API(
             except Exception:
                 mod_log.exception("Errored during door state event callback")
 
+    def _send_module_notification(self, event: HardwareEvent) -> None:
+        if not isinstance(event, AsynchronousModuleErrorNotification):
+            return
+        mod_log.info(
+            f"Forwarding module event {event.event} for {event.module_model} {event.module_serial} at {event.port}"
+        )
+        for cb in self._callbacks:
+            try:
+                cb(event)
+            except Exception:
+                mod_log.exception("Errored during module asynchronous callback")
+
     def _reset_last_mount(self) -> None:
         self._last_moved_mount = None
 
@@ -247,7 +261,9 @@ class API(
             )
             await api_instance.cache_instruments()
             module_controls = await AttachedModulesControl.build(
-                api_instance, board_revision=backend.board_revision
+                api_instance,
+                board_revision=backend.board_revision,
+                event_callback=api_instance._send_module_notification,
             )
             backend.module_controls = module_controls
             checked_loop.create_task(backend.watch(loop=checked_loop))
@@ -306,7 +322,9 @@ class API(
         )
         await api_instance.cache_instruments()
         module_controls = await AttachedModulesControl.build(
-            api_instance, board_revision=backend.board_revision
+            api_instance,
+            board_revision=backend.board_revision,
+            event_callback=api_instance._send_module_notification,
         )
         backend.module_controls = module_controls
         await backend.watch()
@@ -1312,9 +1330,10 @@ class API(
             self.is_simulator
         ), "Cannot build simulating module from non-simulating hardware control API"
 
-        return await self._backend.module_controls.build_module(
-            port="",
-            usb_port=USBPort(name="", port_number=1, port_group=PortGroup.MAIN),
+        return await self._backend.module_controls.register_simulated_module(
+            simulated_usb_port=USBPort(
+                name="", port_number=1, port_group=PortGroup.MAIN
+            ),
             type=modules.ModuleType.from_model(model),
             sim_model=model.value,
         )

opentrons/hardware_control/backends/controller.py

@@ -360,13 +360,19 @@ class Controller:
         """Run a probe and return the new position dict"""
         return await self._smoothie_driver.probe_axis(axis, distance)
 
-    async def clean_up(self) -> None:
+    async def clean_up(self) -> None:  # noqa: C901
         try:
             loop = asyncio.get_event_loop()
         except RuntimeError:
             return
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
         if hasattr(self, "_event_watcher"):
-            if loop.is_running() and self._event_watcher:
+            if (
+                loop.is_running()
+                and self._event_watcher
+                and not self._event_watcher.closed
+            ):
                 self._event_watcher.close()
         if hasattr(self, "gpio_chardev"):
             try:

opentrons/hardware_control/backends/ot3controller.py

@@ -1398,6 +1398,9 @@ class OT3Controller(FlexBackend):
         except RuntimeError:
             return
 
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
+
         if hasattr(self, "_event_watcher"):
             if (
                 loop.is_running()

opentrons/hardware_control/backends/ot3simulator.py

@@ -728,7 +728,8 @@ class OT3Simulator(FlexBackend):
     @ensure_yield
     async def clean_up(self) -> None:
         """Clean up."""
-        pass
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
 
     @staticmethod
     def _get_home_position() -> Dict[Axis, float]:

opentrons/hardware_control/backends/simulator.py

@@ -414,7 +414,8 @@ class Simulator:
 
     @ensure_yield
     async def clean_up(self) -> None:
-        pass
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
 
     @ensure_yield
     async def configure_mount(

opentrons/hardware_control/backends/subsystem_manager.py

@@ -91,6 +91,8 @@ class SubsystemManager:
         self._present_tools = tools.types.ToolSummary(
             left=None, right=None, gripper=None
         )
+        # This is intended to be an internal variable but is modified in unit tests to avoid long timeouts
+        self._check_device_update_timeout = 10.0
 
     @property
     def ok(self) -> bool:
@@ -183,11 +185,12 @@ class SubsystemManager:
             return self._tool_task_state is True
 
     async def _check_devices_after_update(
-        self, devices: Set[SubSystem], timeout_sec: float = 10.0
+        self, devices: Set[SubSystem], timeout_sec: Optional[float] = None
     ) -> None:
         try:
             await asyncio.wait_for(
-                self._do_check_devices_after_update(devices), timeout=timeout_sec
+                self._do_check_devices_after_update(devices),
+                timeout=timeout_sec or self._check_device_update_timeout,
             )
         except asyncio.TimeoutError:
             raise RuntimeError("Device failed to come back after firmware update")

opentrons/hardware_control/module_control.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 import asyncio
 import logging
 import re
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union, Callable
 from glob import glob
 
+from opentrons_shared_data.errors.exceptions import EnumeratedError
+
 from opentrons.config import IS_ROBOT, IS_LINUX
 from opentrons.drivers.rpi_drivers import types, interfaces, usb, usb_simulator
 from opentrons.hardware_control.emulation.module_server.helpers import (
@@ -19,8 +21,16 @@ from opentrons.hardware_control.modules.module_calibration import (
 from opentrons.hardware_control.modules.types import ModuleAtPort, ModuleType
 from opentrons.hardware_control.modules import SimulatingModuleAtPort
 
+
 from opentrons.types import Point
-from .types import AionotifyEvent, BoardRevision, OT3Mount, StatusBarUpdateEvent
+from .types import (
+    AionotifyEvent,
+    BoardRevision,
+    OT3Mount,
+    StatusBarUpdateEvent,
+    HardwareEvent,
+    AsynchronousModuleErrorNotification,
+)
 from . import modules
 
 if TYPE_CHECKING:
@@ -51,10 +61,21 @@ class AttachedModulesControl:
         self,
         api: Union["API", "OT3API"],
         usb: interfaces.USBDriverInterface,
+        event_callback: Callable[[HardwareEvent], None],
     ) -> None:
         self._available_modules: List[modules.AbstractModule] = []
         self._api = api
         self._usb = usb
+        self._event_callback = event_callback
+        if not IS_ROBOT and not api.is_simulator:
+            # Start task that registers emulated modules.
+            self._emulation_listen_task: asyncio.Task[
+                None
+            ] | None = api.loop.create_task(
+                listen_module_connection(self.register_modules)
+            )
+        else:
+            self._emulation_listen_task = None
 
     def subscribe_to_api_event(self, module: modules.AbstractModule) -> None:
         self._api.add_status_bar_listener(module.event_listener)
@@ -64,22 +85,20 @@ class AttachedModulesControl:
         cls,
         api_instance: Union["API", "OT3API"],
         board_revision: BoardRevision,
+        event_callback: Callable[[HardwareEvent], None],
     ) -> AttachedModulesControl:
         usb_instance = (
             usb.USBBus(board_revision)
             if not api_instance.is_simulator and IS_ROBOT
             else usb_simulator.USBBusSimulator()
         )
-        mc_instance = cls(api=api_instance, usb=usb_instance)
+        mc_instance = cls(
+            api=api_instance, usb=usb_instance, event_callback=event_callback
+        )
 
         if not api_instance.is_simulator:
             # Do an initial scan of modules.
             await mc_instance.register_modules(mc_instance.scan())
-            if not IS_ROBOT:
-                # Start task that registers emulated modules.
-                api_instance.loop.create_task(
-                    listen_module_connection(mc_instance.register_modules)
-                )
 
         return mc_instance
 
@@ -87,6 +106,37 @@ class AttachedModulesControl:
     def available_modules(self) -> List[modules.AbstractModule]:
         return self._available_modules
 
+    async def clean_up(self) -> None:
+        """Clean up all registered modules and emulator scanning tasks (if any)."""
+        for module in self._available_modules:
+            await module.cleanup()
+        if self._emulation_listen_task is not None:
+            self._emulation_listen_task.cancel("cleanup")
+            try:
+                await self._emulation_listen_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                log.exception("Exception cleaning up emulation listen task")
+            finally:
+                self._emulation_listen_task = None
+
+    async def register_simulated_module(
+        self,
+        simulated_usb_port: types.USBPort,
+        type: modules.ModuleType,
+        sim_model: str,
+    ) -> modules.AbstractModule:
+        """Register a simulated module."""
+        module = await self.build_module(
+            "", simulated_usb_port, type, sim_model, sim_serial_number=None
+        )
+        self._available_modules.append(module)
+        self._available_modules = sorted(
+            self._available_modules, key=modules.AbstractModule.sort_key
+        )
+        return module
+
     async def build_module(
         self,
         port: str,
@@ -105,6 +155,7 @@ class AttachedModulesControl:
             sim_model=sim_model,
             sim_serial_number=sim_serial_number,
             disconnected_callback=self._disconnected_callback,
+            error_callback=self._async_error_callback,
         )
         last_event = StatusBarUpdateEvent(
             self._api.get_status_bar_state(), self._api.get_status_bar_enabled()
@@ -121,6 +172,29 @@ class AttachedModulesControl:
             self._api.loop,
         )
 
+    def _async_error_callback(
+        self,
+        exc: Exception,
+        model: str,
+        port: str,
+        serial: str | None,
+    ) -> None:
+        """Used by the module to indicate it saw an error from its data poller."""
+        try:
+            self._api.loop.call_soon(
+                self._event_callback,
+                AsynchronousModuleErrorNotification(
+                    exception=EnumeratedError.ensure(exc),
+                    module_serial=serial,
+                    module_model=modules.module_model_from_string(model),
+                    port=port,
+                ),
+            )
+        except Exception:
+            log.exception(
+                f"Async error callback for module {model} {serial} at {port} for exc {exc} failed"
+            )
+
     async def unregister_modules(
         self,
         mods_at_ports: Union[

opentrons/hardware_control/modules/__init__.py

@@ -27,7 +27,9 @@ from .types import (
     LiveData,
     ModuleData,
     ModuleDataValidator,
+    module_model_from_string,
 )
+
 from .errors import (
     UpdateError,
     AbsorbanceReaderDisconnectedError,
@@ -66,4 +68,5 @@ __all__ = [
     "FlexStackerStatus",
     "PlatformState",
     "StackerAxisState",
+    "module_model_from_string",
 ]

opentrons/hardware_control/modules/absorbance_reader.py

@@ -21,6 +21,7 @@ from opentrons.hardware_control.poller import Poller, Reader
 from opentrons.hardware_control.modules import mod_abc
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
+    ModuleErrorCallback,
     ModuleType,
     AbsorbanceReaderStatus,
     LiveData,
@@ -104,12 +105,13 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
         poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "AbsorbanceReader":
         """
         Build and connect to an AbsorbanceReader
@@ -152,6 +154,7 @@ class AbsorbanceReader(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
 
         try:
@@ -170,8 +173,9 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Mapping[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
     ) -> None:
         """
         Constructor
@@ -193,6 +197,7 @@ class AbsorbanceReader(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         self._device_info = device_info
         self._reader = reader
@@ -371,3 +376,5 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         self._error = str(error)
         if isinstance(error, AbsorbanceReaderDisconnectedError):
             self.disconnected_callback()
+        else:
+            self.error_callback(error)

opentrons/hardware_control/modules/flex_stacker.py

@@ -44,6 +44,7 @@ from opentrons.hardware_control.modules.types import (
     FlexStackerStatus,
     HopperDoorState,
     LatchState,
+    ModuleErrorCallback,
     ModuleDisconnectedCallback,
     ModuleType,
     PlatformState,
@@ -215,12 +216,13 @@ class FlexStacker(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        poll_interval_seconds: Optional[float] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
+        poll_interval_seconds: float | None = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "FlexStacker":
         """
         Build a FlexStacker
@@ -259,11 +261,9 @@ class FlexStacker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
 
-        # Set initialized callback
-        reader.set_initialized_callback(module._initialized_callback)
-
         # Enable stallguard
         for axis, config in STALLGUARD_CONFIG.items():
             await driver.set_stallguard_threshold(
@@ -286,8 +286,9 @@ class FlexStacker(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Mapping[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
     ):
         super().__init__(
             port=port,
@@ -295,6 +296,7 @@ class FlexStacker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         self._device_info = device_info
         self._driver = driver
@@ -304,12 +306,20 @@ class FlexStacker(mod_abc.AbstractModule):
         self._stacker_status = FlexStackerStatus.IDLE
         self._last_status_bar_event: Optional[StatusBarUpdateEvent] = None
         self._should_identify = False
+        # Set initialized callback
+        self._unsubscribe_init = reader.set_initialized_callback(
+            self._initialized_callback
+        )
+        self._unsubscribe_error = reader.set_error_callback(self._async_error_callback)
 
     async def _initialized_callback(self) -> None:
         """Called by the reader once the module is initialized."""
         if self._last_status_bar_event:
             await self._handle_status_bar_event(self._last_status_bar_event)
 
+    def _async_error_callback(self, exception: Exception) -> None:
+        self.error_callback(exception)
+
     async def cleanup(self) -> None:
         """Stop the poller task"""
         await self._poller.stop()
@@ -864,10 +874,27 @@ class FlexStackerReader(Reader):
         self.installation_detected = False
         self._refresh_state = False
         self._initialized_callback: Optional[Callable[[], Awaitable[None]]] = None
+        self._error_callback: Optional[Callable[[Exception], None]] = None
 
-    def set_initialized_callback(self, callback: Callable[[], Awaitable[None]]) -> None:
+    def set_initialized_callback(
+        self, callback: Callable[[], Awaitable[None]]
+    ) -> Callable[[], None]:
         """Sets the callback used when done initializing the module."""
         self._initialized_callback = callback
+        return self._remove_init_callback
+
+    def _remove_init_callback(self) -> None:
+        self._initialized_callback = None
+
+    def set_error_callback(
+        self, error_callback: Callable[[Exception], None]
+    ) -> Callable[[], None]:
+        """Register a handler for asynchronous hardware errors."""
+        self._error_callback = error_callback
+        return self._remove_error_callback
+
+    def _remove_error_callback(self) -> None:
+        self._error_callback = None
 
     async def read(self) -> None:
         await self.get_door_closed()
@@ -942,6 +969,8 @@ class FlexStackerReader(Reader):
         if exception is None:
             self.error = None
         else:
+            if self._error_callback:
+                self._error_callback(exception)
             try:
                 self.error = str(exception.args[0])
             except Exception: