opentrons 8.7.0a6__py3-none-any.whl → 8.7.0a7__py3-none-any.whl

opentrons/hardware_control/emulation/connection_handler.py

@@ -27,12 +27,15 @@ class ConnectionHandler:
             try:
                 response = self._emulator.handle(line.decode().strip())
                 if response:
-                    response = f"{response}\r\n"
-                    logger.debug("%s Sending: %s", emulator_name, response)
-                    writer.write(response.encode())
+                    response_bytes = response.encode() + self._emulator.get_terminator()
+                    logger.debug(f"{emulator_name} Sending: {response_bytes!r}")
+                    writer.write(response_bytes)
             except Exception as e:
                 logger.exception("%s exception", emulator_name)
-                writer.write(f"Error: {str(e)}\r\n".encode())
+                writer.write(
+                    f"Error: {str(e)} ".encode() + self._emulator.get_terminator()
+                )
 
-            writer.write(self._emulator.get_ack())
+            if self._emulator.get_autoack():
+                writer.write(self._emulator.get_ack())
             await writer.drain()

opentrons/hardware_control/emulation/heater_shaker.py

@@ -2,6 +2,7 @@
 
 The purpose is to provide a fake backend that responds to GCODE commands.
 """
+
 import logging
 from time import sleep
 from typing import (
@@ -50,6 +51,7 @@ class HeaterShakerEmulator(AbstractEmulator):
             GCODE.CLOSE_LABWARE_LATCH.value: self._close_labware_latch,
             GCODE.GET_LABWARE_LATCH_STATE.value: self._get_labware_latch_state,
             GCODE.DEACTIVATE_HEATER.value: self._deactivate_heater,
+            GCODE.GET_ERROR_STATE.value: self._get_error_state,
         }
         self.reset()
 
@@ -60,7 +62,6 @@ class HeaterShakerEmulator(AbstractEmulator):
         return None if not joined else joined
 
     def reset(self) -> None:
-
         self._temperature = Temperature(
             per_tick=self._settings.temperature.degrees_per_tick,
             current=self._settings.temperature.starting,
@@ -145,6 +146,14 @@ class HeaterShakerEmulator(AbstractEmulator):
         self._temperature.deactivate(TEMPERATURE_ROOM)
         return "M106"
 
-    @staticmethod
-    def get_terminator() -> bytes:
+    def _get_error_state(self, command: Command) -> str:
+        return f"M411 {HS_ACK}M411"
+
+    def get_terminator(self) -> bytes:
         return b"\n"
+
+    def get_ack(self) -> bytes:
+        return HS_ACK.encode()
+
+    def get_autoack(self) -> bool:
+        return False

opentrons/hardware_control/emulation/settings.py

@@ -90,7 +90,7 @@ class Settings(BaseSettings):
     )
     thermocycler: ThermocyclerSettings = ThermocyclerSettings(
         serial_number="thermocycler_emulator",
-        model="v02",
+        model="thermocyclerModuleV2",
         version="v1.1.0",
         lid_temperature=TemperatureModelSettings(),
         plate_temperature=TemperatureModelSettings(),

opentrons/hardware_control/emulation/thermocycler.py

@@ -5,8 +5,15 @@ The purpose is to provide a fake backend that responds to GCODE commands.
 
 import logging
 from typing import Optional
-from opentrons.drivers.thermocycler.driver import GCODE
+from opentrons.drivers.thermocycler.driver import (
+    GCODE,
+    TC_GEN2_ACK,
+    TC_GEN2_SERIAL_ACK,
+    TC_ACK as TC_GEN1_ACK,
+    SERIAL_ACK as TC_GEN1_SERIAL_ACK,
+)
 from opentrons.drivers.types import ThermocyclerLidStatus
+from opentrons.hardware_control.modules.types import ThermocyclerModuleModel
 from opentrons.hardware_control.emulation.parser import Parser, Command
 from opentrons.hardware_control.emulation.settings import ThermocyclerSettings
 
@@ -29,13 +36,31 @@ class ThermocyclerEmulator(AbstractEmulator):
     def __init__(self, parser: Parser, settings: ThermocyclerSettings) -> None:
         self._parser = parser
         self._settings = settings
+        # I hate this. These modules do not return anything like this for their actual versions
+        # (gen2 returns "Opentrons-thermocycler-gen2" for instance) and this is not what any of
+        # the settings anywhere use.
+        self._model = (
+            ThermocyclerModuleModel.THERMOCYCLER_V1
+            if settings.model in ["thermocyclerModuleV1", "v1", "v01"]
+            else ThermocyclerModuleModel.THERMOCYCLER_V2
+        )
+        self._terminator = (
+            TC_GEN1_SERIAL_ACK
+            if self._model is ThermocyclerModuleModel.THERMOCYCLER_V1
+            else TC_GEN2_SERIAL_ACK
+        )
+        self._ack = (
+            TC_GEN1_ACK
+            if self._model is ThermocyclerModuleModel.THERMOCYCLER_V1
+            else TC_GEN2_ACK
+        )
         self.reset()
 
     def handle(self, line: str) -> Optional[str]:
         """Handle a line"""
         results = (self._handle(c) for c in self._parser.parse(line))
-        joined = " ".join(r for r in results if r)
-        return None if not joined else joined
+        joined = " ".join(f"{r} {self._ack}" for r in results if r)
+        return self._ack if not joined else joined
 
     def reset(self) -> None:
         self._lid_temperature = Temperature(
@@ -50,6 +75,12 @@ class ThermocyclerEmulator(AbstractEmulator):
         self.plate_volume = util.OptionalValue[float]()
         self.plate_ramp_rate = util.OptionalValue[float]()
 
+    def _pref(self, command: Command) -> str:
+        if self._model is ThermocyclerModuleModel.THERMOCYCLER_V1:
+            return ""
+        else:
+            return f"{command.gcode} "
+
     def _handle(self, command: Command) -> Optional[str]:  # noqa: C901
         """
         Handle a command.
@@ -62,7 +93,7 @@ class ThermocyclerEmulator(AbstractEmulator):
         elif command.gcode == GCODE.CLOSE_LID:
             self.lid_status = ThermocyclerLidStatus.CLOSED
         elif command.gcode == GCODE.GET_LID_STATUS:
-            return f"Lid:{self.lid_status}"
+            return self._pref(command) + f"Lid:{self.lid_status}"
         elif command.gcode == GCODE.SET_LID_TEMP:
             temperature = command.params["S"]
             assert isinstance(
@@ -76,7 +107,7 @@ class ThermocyclerEmulator(AbstractEmulator):
                 f"H:none Total_H:none"
             )
             self._lid_temperature.tick()
-            return res
+            return self._pref(command) + res
         elif command.gcode == GCODE.EDIT_PID_PARAMS:
             pass
         elif command.gcode == GCODE.SET_PLATE_TEMP:
@@ -105,7 +136,7 @@ class ThermocyclerEmulator(AbstractEmulator):
                 f"Total_H:{plate_total_hold_time} "
             )
             self._plate_temperature.tick()
-            return res
+            return self._pref(command) + res
         elif command.gcode == GCODE.SET_RAMP_RATE:
             self.plate_ramp_rate.val = command.params["S"]
         elif command.gcode == GCODE.DEACTIVATE_ALL:
@@ -116,13 +147,34 @@ class ThermocyclerEmulator(AbstractEmulator):
         elif command.gcode == GCODE.DEACTIVATE_BLOCK:
             self._plate_temperature.deactivate(temperature=util.TEMPERATURE_ROOM)
         elif command.gcode == GCODE.DEVICE_INFO:
-            return (
-                f"serial:{self._settings.serial_number} "
-                f"model:{self._settings.model} "
-                f"version:{self._settings.version}"
-            )
-        return None
+            # the gen2 returns a completely different device info format than the
+            # gen1 which is pretty cool
+            if self._model == ThermocyclerModuleModel.THERMOCYCLER_V1:
+                return (
+                    f"serial:{self._settings.serial_number} "
+                    f"model:{self._settings.model} "
+                    f"version:{self._settings.version}"
+                )
+            else:
+                return (
+                    command.gcode
+                    + " "
+                    + (
+                        f"FW:{self._settings.version} "
+                        f"HW:{self._settings.model} "
+                        f"SerialNo:{self._settings.serial_number}"
+                    )
+                )
+        elif command.gcode == GCODE.GET_ERROR_STATE:
+            if self._model is ThermocyclerModuleModel.THERMOCYCLER_V2:
+                return self._pref(command) + self._ack + self._pref(command)
+        return self._pref(command)
+
+    def get_terminator(self) -> bytes:
+        return self._terminator.encode()
+
+    def get_ack(self) -> bytes:
+        return self._ack.encode()
 
-    @staticmethod
-    def get_terminator() -> bytes:
-        return b"\r\n"
+    def get_autoack(self) -> bool:
+        return False

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:

opentrons/hardware_control/modules/heater_shaker.py

@@ -2,19 +2,21 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, Mapping
+from typing import Optional, Mapping, Callable
 from typing_extensions import Final
 
 from opentrons.drivers.rpi_drivers.types import USBPort
 from opentrons.drivers.heater_shaker.driver import HeaterShakerDriver
 from opentrons.drivers.heater_shaker.abstract import AbstractHeaterShakerDriver
 from opentrons.drivers.heater_shaker.simulator import SimulatingDriver
+from opentrons.drivers.asyncio.communication.errors import UnhandledGcode
 from opentrons.drivers.types import Temperature, RPM, HeaterShakerLabwareLatchStatus
 from opentrons.hardware_control.execution_manager import ExecutionManager
 from opentrons.hardware_control.poller import Reader, Poller
 from opentrons.hardware_control.modules import mod_abc, update
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
+    ModuleErrorCallback,
     ModuleType,
     TemperatureStatus,
     SpeedStatus,
@@ -47,12 +49,13 @@ class HeaterShaker(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,
     ) -> "HeaterShaker":
         """
         Build a HeaterShaker
@@ -67,6 +70,7 @@ class HeaterShaker(mod_abc.AbstractModule):
             loop: Loop
             sim_model: The model name used by simulator
             disconnected_callback: Callback to inform the module controller that the device was disconnected
+            error_callback: Callback to inform the module controller of an asynchronous error
 
         Returns:
             HeaterShaker instance
@@ -91,6 +95,7 @@ class HeaterShaker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
 
         try:
@@ -109,8 +114,9 @@ class HeaterShaker(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,
@@ -118,14 +124,22 @@ class HeaterShaker(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
         self._reader = reader
         self._poller = poller
+        self._unsubscribe_reader = self._reader.register_error_handler(
+            self._handle_error
+        )
+
+    def _handle_error(self, error: Exception) -> None:
+        self.error_callback(error)
 
     async def cleanup(self) -> None:
         """Stop the poller task"""
+        self._unsubscribe_reader()
         await self._poller.stop()
         await self._driver.disconnect()
 
@@ -397,11 +411,22 @@ class HeaterShakerReader(Reader):
         self.labware_latch = HeaterShakerLabwareLatchStatus.IDLE_UNKNOWN
         self.error: Optional[str] = None
         self._driver = driver
+        self._handle_error: Callable[[Exception], None] | None = None
+
+    def register_error_handler(
+        self, handle_error: Callable[[Exception], None]
+    ) -> Callable[[], None]:
+        self._handle_error = handle_error
+        return self._unsubscribe_error_handler
+
+    def _unsubscribe_error_handler(self) -> None:
+        self._handle_error = None
 
     async def read(self) -> None:
         await self.read_temperature()
         await self.read_rpm()
         await self.read_labware_latch()
+        await self._read_errors()
         self._set_error(None)
 
     def on_error(self, exception: Exception) -> None:
@@ -420,7 +445,19 @@ class HeaterShakerReader(Reader):
         if exception is None:
             self.error = None
         else:
+            if self._handle_error:
+                self._handle_error(exception)
             try:
                 self.error = str(exception.args[0])
             except Exception:
                 self.error = repr(exception)
+
+    async def _read_errors(self) -> None:
+        try:
+            await self._driver.get_error_state()
+        except UnhandledGcode:
+            # This device's firmware cannot accept this command, because it
+            # hasn't been updated or because it's a gen1. Ignore the result.
+            pass
+        # If the error is one we should let pass, raise it so the top level
+        # error handler can take it.