opentrons 8.3.2__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/drivers/flex_stacker/errors.py

@@ -0,0 +1,64 @@
+"""Stacker-specific error codes and exceptions."""
+
+from opentrons.drivers.asyncio.communication.errors import (
+    BaseErrorCode,
+    ErrorResponse,
+    UnhandledGcode,
+)
+
+
+class EStopTriggered(ErrorResponse):
+    """Raised when the estop is triggered during a move."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class MotorStallDetected(ErrorResponse):
+    """Raised when a motor stall is detected."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class MotorQueueFull(ErrorResponse):
+    """Raised when the motor command queue is full."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class UnexpectedLimitSwitch(ErrorResponse):
+    """Raised when an unexpected limit switch is triggered."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class MotorBusy(ErrorResponse):
+    """Raised when a motor is busy."""
+
+    # TODO: differentiate between motors
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class StopRequested(ErrorResponse):
+    """Raised when a stop is requested during a movement."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class StackerErrorCodes(BaseErrorCode):
+    """Stacker-specific error codes."""
+
+    UNHANDLED_GCODE = ("ERR003", UnhandledGcode)
+    ESTOP_TRIGGERED = ("ERR006", EStopTriggered)
+    MOTOR_STALL_DETECTED = ("ERR403", MotorStallDetected)
+    MOTOR_QUEUE_FULL = ("ERR404", MotorQueueFull)
+    UNEXPECTED_LIMIT_SWITCH = ("ERR405", UnexpectedLimitSwitch)
+    X_MOTOR_BUSY = ("ERR501", MotorBusy)
+    Z_MOTOR_BUSY = ("ERR502", MotorBusy)
+    L_MOTOR_BUSY = ("ERR503", MotorBusy)
+    STOP_REQUESTED = ("ERR504", StopRequested)

opentrons/drivers/flex_stacker/simulator.py

@@ -1,9 +1,16 @@
-from typing import Optional
+from typing import List, Optional, Dict
 
+from opentrons.drivers.flex_stacker.driver import NUMBER_OF_BINS
 from opentrons.util.async_helpers import ensure_yield
 
-from .abstract import AbstractStackerDriver
+from .abstract import AbstractFlexStackerDriver
 from .types import (
+    ActiveRange,
+    LEDColor,
+    LEDPattern,
+    MeasurementKind,
+    MoveResult,
+    SpadMapID,
     StackerAxis,
     PlatformStatus,
     Direction,
@@ -11,10 +18,18 @@ from .types import (
     HardwareRevision,
     MoveParams,
     LimitSwitchStatus,
+    StallGuardParams,
+    TOFConfiguration,
+    TOFMeasurement,
+    TOFMeasurementResult,
+    TOFSensor,
+    TOFSensorMode,
+    TOFSensorState,
+    TOFSensorStatus,
 )
 
 
-class SimulatingDriver(AbstractStackerDriver):
+class SimulatingDriver(AbstractFlexStackerDriver):
     """FLEX Stacker driver simulator."""
 
     def __init__(self, serial_number: Optional[str] = None) -> None:
@@ -22,33 +37,51 @@ class SimulatingDriver(AbstractStackerDriver):
         self._limit_switch_status = LimitSwitchStatus(False, False, False, False, False)
         self._platform_sensor_status = PlatformStatus(False, False)
         self._door_closed = True
+        self._install_detected = True
+        self._connected = True
+        self._stallgard_threshold = {
+            a: StallGuardParams(a, False, 0) for a in StackerAxis
+        }
+        self._motor_registers: Dict[StackerAxis, Dict[int, int]] = {
+            a: {} for a in StackerAxis
+        }
+        self._tof_registers: Dict[TOFSensor, Dict[int, int]] = {
+            a: {} for a in TOFSensor
+        }
+        self._tof_sensor_status: Dict[TOFSensor, TOFSensorStatus] = {
+            s: TOFSensorStatus(s, TOFSensorState.IDLE, TOFSensorMode.MEASURE, True)
+            for s in TOFSensor
+        }
+        self._tof_sensor_configuration: Dict[TOFSensor, TOFConfiguration] = {
+            s: TOFConfiguration(
+                s, SpadMapID.SPAD_MAP_ID_14, ActiveRange.SHORT_RANGE, 4000, 500, True
+            )
+            for s in TOFSensor
+        }
 
-    def set_limit_switch(self, status: LimitSwitchStatus) -> bool:
+    def set_limit_switch(self, status: LimitSwitchStatus) -> None:
         self._limit_switch_status = status
-        return True
 
-    def set_platform_sensor(self, status: PlatformStatus) -> bool:
+    def set_platform_sensor(self, status: PlatformStatus) -> None:
         self._platform_sensor_status = status
-        return True
 
-    def set_door_closed(self, door_closed: bool) -> bool:
+    def set_door_closed(self, door_closed: bool) -> None:
         self._door_closed = door_closed
-        return True
 
     @ensure_yield
     async def connect(self) -> None:
         """Connect to stacker."""
-        pass
+        self._connected = True
 
     @ensure_yield
     async def disconnect(self) -> None:
         """Disconnect from stacker."""
-        pass
+        self._connected = False
 
     @ensure_yield
     async def is_connected(self) -> bool:
         """Check connection to stacker."""
-        return True
+        return self._connected
 
     @ensure_yield
     async def get_device_info(self) -> StackerInfo:
@@ -56,14 +89,139 @@ class SimulatingDriver(AbstractStackerDriver):
         return StackerInfo(fw="stacker-fw", hw=HardwareRevision.EVT, sn=self._sn)
 
     @ensure_yield
-    async def set_serial_number(self, sn: str) -> bool:
+    async def set_serial_number(self, sn: str) -> None:
         """Set Serial Number."""
-        return True
+        self._sn = sn
+
+    @ensure_yield
+    async def enable_motors(self, axis: List[StackerAxis]) -> None:
+        """Enables the axis motor if present, disables it otherwise."""
+        pass
+
+    @ensure_yield
+    async def stop_motors(self) -> None:
+        """Stop all motor movement."""
+        pass
+
+    @ensure_yield
+    async def set_run_current(self, axis: StackerAxis, current: float) -> None:
+        """Set axis peak run current in amps."""
+        pass
+
+    @ensure_yield
+    async def set_ihold_current(self, axis: StackerAxis, current: float) -> None:
+        """Set axis hold current in amps."""
+        pass
+
+    @ensure_yield
+    async def set_stallguard_threshold(
+        self, axis: StackerAxis, enable: bool, threshold: int
+    ) -> None:
+        """Enables and sets the stallguard threshold for the given axis motor."""
+        self._stallgard_threshold[axis] = StallGuardParams(axis, enable, threshold)
+
+    @ensure_yield
+    async def enable_tof_sensor(self, sensor: TOFSensor, enable: bool) -> None:
+        """Enable or disable the TOF sensor."""
+        state = TOFSensorState.IDLE if enable else TOFSensorState.DISABLED
+        self._tof_sensor_status[sensor].state = state
+        self._tof_sensor_status[sensor].ok = enable
+
+    @ensure_yield
+    async def manage_tof_measurement(
+        self,
+        sensor: TOFSensor,
+        kind: MeasurementKind = MeasurementKind.HISTOGRAM,
+        start: bool = True,
+    ) -> TOFMeasurement:
+        """Start or stop Measurements from the TOF sensor."""
+        return TOFMeasurement(
+            sensor=sensor,
+            kind=kind,
+            cancelled=not start,
+            # Each histogram frame is 135 bytes and there are 30 frames.
+            # (3b header + 4b sub-header + 128 data) * 30 frames = 3840b.
+            # The firmware sends 0 when the measurement is cancelled.
+            total_bytes=3840 if start else 0,
+        )
+
+    @ensure_yield
+    async def get_tof_histogram(self, sensor: TOFSensor) -> TOFMeasurementResult:
+        """Get the full histogram measurement from the TOF sensor."""
+        return TOFMeasurementResult(
+            sensor=sensor,
+            kind=MeasurementKind.HISTOGRAM,
+            bins={c: [b for b in range(NUMBER_OF_BINS)] for c in range(10)},
+        )
+
+    async def set_tof_configuration(
+        self,
+        sensor: TOFSensor,
+        spad_map_id: SpadMapID,
+        active_range: Optional[ActiveRange] = None,
+        kilo_iterations: Optional[int] = None,
+        report_period_ms: Optional[int] = None,
+        histogram_dump: Optional[bool] = None,
+    ) -> None:
+        """Set the configuration of the TOF sensor.
+
+        :param sensor: The TOF sensor to configure.
+        :param spad_map_id: The pre-defined SPAD map which sets the fov and focus area (14 default).
+        :active_range: The operating mode Short-range high-accuracy (default) or long range.
+        :kilo_iterations: The Measurement iterations times 1024 (4000 default).
+        :report_period_ms: The reporting period before each measurement (500 default).
+        :histogram_dump: Enables/Disables histogram measurements (True default).
+        :return: None
+        """
+        config = self._tof_sensor_configuration[sensor]
+        config.spad_map_id = spad_map_id
+        config.active_range = active_range or config.active_range
+        config.kilo_iterations = kilo_iterations or config.kilo_iterations
+        config.report_period_ms = report_period_ms or config.report_period_ms
+        config.histogram_dump = histogram_dump or config.histogram_dump
+
+    async def get_tof_configuration(self, sensor: TOFSensor) -> TOFConfiguration:
+        """Get the configuration of the TOF sensor."""
+        return self._tof_sensor_configuration[sensor]
+
+    @ensure_yield
+    async def set_motor_driver_register(
+        self, axis: StackerAxis, reg: int, value: int
+    ) -> None:
+        """Set the register of the given motor axis driver to the given value."""
+        self._motor_registers[axis].update({reg: value})
+
+    @ensure_yield
+    async def get_motor_driver_register(self, axis: StackerAxis, reg: int) -> int:
+        """Gets the register value of the given motor axis driver."""
+        return self._motor_registers[axis].get(reg, 0)
+
+    @ensure_yield
+    async def set_tof_driver_register(
+        self, sensor: TOFSensor, reg: int, value: int
+    ) -> None:
+        """Set the register of the given tof sensor driver to the given value."""
+        self._tof_registers[sensor].update({reg: value})
+
+    @ensure_yield
+    async def get_tof_driver_register(self, sensor: TOFSensor, reg: int) -> int:
+        """Gets the register value of the given tof sensor driver."""
+        return self._tof_registers[sensor].get(reg, 0)
 
     @ensure_yield
-    async def stop_motor(self) -> bool:
-        """Stop motor movement."""
-        return True
+    async def get_tof_sensor_status(self, sensor: TOFSensor) -> TOFSensorStatus:
+        """Get the status of the tof sensor."""
+        return self._tof_sensor_status[sensor]
+
+    @ensure_yield
+    async def get_motion_params(self, axis: StackerAxis) -> MoveParams:
+        """Get the motion parameters used by the given axis motor."""
+        return MoveParams(1, 1, 1)
+
+    @ensure_yield
+    async def get_stallguard_threshold(self, axis: StackerAxis) -> StallGuardParams:
+        """Get the stallguard parameters by the given axis motor."""
+        return self._stallgard_threshold[axis]
 
     @ensure_yield
     async def get_limit_switch(self, axis: StackerAxis, direction: Direction) -> bool:
@@ -79,11 +237,16 @@ class SimulatingDriver(AbstractStackerDriver):
         return self._limit_switch_status
 
     @ensure_yield
-    async def get_platform_sensor_status(self) -> PlatformStatus:
+    async def get_platform_sensor(self, direction: Direction) -> bool:
         """Get platform sensor status.
 
-        :return: True if platform is detected, False otherwise
+        :return: True if platform is present, False otherwise
         """
+        return self._platform_sensor_status.get(direction)
+
+    @ensure_yield
+    async def get_platform_status(self) -> PlatformStatus:
+        """Get platform status."""
         return self._platform_sensor_status
 
     @ensure_yield
@@ -94,16 +257,51 @@ class SimulatingDriver(AbstractStackerDriver):
         """
         return self._door_closed
 
+    @ensure_yield
+    async def get_installation_detected(self) -> bool:
+        """Get whether or not installation is detected.
+
+        :return: True if installation is detected, False otherwise
+        """
+        return self._install_detected
+
     @ensure_yield
     async def move_in_mm(
         self, axis: StackerAxis, distance: float, params: MoveParams | None = None
-    ) -> bool:
-        """Move axis."""
-        return True
+    ) -> MoveResult:
+        """Move axis by the given distance in mm."""
+        return MoveResult.NO_ERROR
 
     @ensure_yield
     async def move_to_limit_switch(
         self, axis: StackerAxis, direction: Direction, params: MoveParams | None = None
-    ) -> bool:
+    ) -> MoveResult:
         """Move until limit switch is triggered."""
-        return True
+        return MoveResult.NO_ERROR
+
+    @ensure_yield
+    async def home_axis(self, axis: StackerAxis, direction: Direction) -> MoveResult:
+        """Home axis."""
+        return MoveResult.NO_ERROR
+
+    @ensure_yield
+    async def set_led(
+        self,
+        power: float,
+        color: Optional[LEDColor] = None,
+        external: Optional[bool] = None,
+        pattern: Optional[LEDPattern] = None,
+        duration: Optional[int] = None,
+        reps: Optional[int] = None,
+    ) -> None:
+        """Set LED Status bar color and pattern."""
+        pass
+
+    @ensure_yield
+    async def enter_programming_mode(self) -> None:
+        """Reboot into programming mode"""
+        pass
+
+    def reset_serial_buffers(self) -> None:
+        """Reset the input and output serial buffers."""
+        pass

opentrons/drivers/flex_stacker/types.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from dataclasses import dataclass, fields
-from typing import List
+from typing import List, Dict, Optional
 
 from opentrons.drivers.command_builder import CommandBuilder
 
@@ -11,13 +11,30 @@ class GCODE(str, Enum):
     MOVE_TO_SWITCH = "G5"
     HOME_AXIS = "G28"
     STOP_MOTORS = "M0"
+    ENABLE_MOTORS = "M17"
     GET_RESET_REASON = "M114"
     DEVICE_INFO = "M115"
     GET_LIMIT_SWITCH = "M119"
-    SET_LED = "M200"
+    GET_MOVE_PARAMS = "M120"
     GET_PLATFORM_SENSOR = "M121"
     GET_DOOR_SWITCH = "M122"
+    GET_INSTALL_DETECTED = "M123"
+    GET_STALLGUARD_THRESHOLD = "M911"
+    GET_MOTOR_DRIVER_REGISTER = "M920"
+    GET_TOF_SENSOR_STATUS = "M215"
+    GET_TOF_DRIVER_REGISTER = "M222"
+    GET_TOF_MEASUREMENT = "M226"
+    ENABLE_TOF_SENSOR = "M224"
+    MANAGE_TOF_MEASUREMENT = "M225"
+    SET_TOF_CONFIGURATION = "M227"
+    GET_TOF_CONFIGURATION = "M228"
+    SET_LED = "M200"
     SET_SERIAL_NUMBER = "M996"
+    SET_RUN_CURRENT = "M906"
+    SET_IHOLD_CURRENT = "M907"
+    SET_STALLGUARD = "M910"
+    SET_MOTOR_DRIVER_REGISTER = "M921"
+    SET_TOF_DRIVER_REGISTER = "M223"
     ENTER_BOOTLOADER = "dfu"
 
     def build_command(self) -> CommandBuilder:
@@ -35,6 +52,7 @@ class HardwareRevision(Enum):
 
     NFF = "nff"
     EVT = "a1"
+    DVT = "b1"
 
 
 @dataclass
@@ -44,18 +62,31 @@ class StackerInfo:
     fw: str
     hw: HardwareRevision
     sn: str
+    rr: int = 0
+
+    def to_dict(self) -> Dict[str, str]:
+        """Build command."""
+        return {
+            "serial": self.sn,
+            "version": self.fw,
+            "model": self.hw.value,
+            "reset_reason": str(self.rr),
+        }
 
 
-class StackerAxis(Enum):
+class StackerAxis(str, Enum):
     """Stacker Axis."""
 
     X = "X"
     Z = "Z"
     L = "L"
 
-    def __str__(self) -> str:
-        """Name."""
-        return self.name
+
+class TOFSensor(str, Enum):
+    """Stacker TOF sensor."""
+
+    X = "X"
+    Z = "Z"
 
 
 class LEDColor(Enum):
@@ -65,13 +96,23 @@ class LEDColor(Enum):
     RED = 1
     GREEN = 2
     BLUE = 3
+    YELLOW = 4
+
+
+class LEDPattern(Enum):
+    """Stacker LED Pattern."""
+
+    STATIC = 0
+    FLASH = 1
+    PULSE = 2
+    CONFIRM = 3
 
 
 class Direction(Enum):
     """Direction."""
 
     RETRACT = 0  # negative
-    EXTENT = 1  # positive
+    EXTEND = 1  # positive
 
     def __str__(self) -> str:
         """Convert to tag for clear logging."""
@@ -79,13 +120,31 @@ class Direction(Enum):
 
     def opposite(self) -> "Direction":
         """Get opposite direction."""
-        return Direction.EXTENT if self == Direction.RETRACT else Direction.RETRACT
+        return Direction.EXTEND if self == Direction.RETRACT else Direction.RETRACT
 
     def distance(self, distance: float) -> float:
         """Get signed distance, where retract direction is negative."""
         return distance * -1 if self == Direction.RETRACT else distance
 
 
+class TOFSensorState(Enum):
+    """TOF Sensor state."""
+
+    DISABLED = 0
+    INITIALIZING = 1
+    IDLE = 2
+    MEASURING = 3
+    ERROR = 4
+
+
+class TOFSensorMode(Enum):
+    """The mode the sensor is in."""
+
+    UNKNOWN = 0
+    MEASURE = 0x03
+    BOOTLOADER = 0x80
+
+
 @dataclass
 class LimitSwitchStatus:
     """Stacker Limit Switch Statuses."""
@@ -104,10 +163,10 @@ class LimitSwitchStatus:
     def get(self, axis: StackerAxis, direction: Direction) -> bool:
         """Get limit switch status."""
         if axis == StackerAxis.X:
-            return self.XE if direction == Direction.EXTENT else self.XR
+            return self.XE if direction == Direction.EXTEND else self.XR
         if axis == StackerAxis.Z:
-            return self.ZE if direction == Direction.EXTENT else self.ZR
-        if direction == Direction.EXTENT:
+            return self.ZE if direction == Direction.EXTEND else self.ZR
+        if direction == Direction.EXTEND:
             raise ValueError("Latch does not have extent limit switch")
         return self.LR
 
@@ -126,13 +185,150 @@ class PlatformStatus:
 
     def get(self, direction: Direction) -> bool:
         """Get platform status."""
-        return self.E if direction == Direction.EXTENT else self.R
+        return self.E if direction == Direction.EXTEND else self.R
+
+    def to_dict(self) -> Dict[str, bool]:
+        """Dict of the data."""
+        return {
+            "extent": self.E,
+            "retract": self.R,
+        }
+
+
+@dataclass
+class TOFSensorStatus:
+    """Stacker TOF sensor status."""
+
+    sensor: TOFSensor
+    state: TOFSensorState
+    mode: TOFSensorMode
+    ok: bool
 
 
 @dataclass
 class MoveParams:
     """Move Parameters."""
 
-    max_speed: float | None = None
-    acceleration: float | None = None
-    max_speed_discont: float | None = None
+    max_speed: float
+    acceleration: float
+    max_speed_discont: float
+
+    @classmethod
+    def get_fields(cls) -> List[str]:
+        """Get parsing fields."""
+        return ["V", "A", "D"]
+
+    def update(
+        self,
+        max_speed: Optional[float] = None,
+        acceleration: Optional[float] = None,
+        max_speed_discont: Optional[float] = None,
+    ) -> "MoveParams":
+        """Update the move parameters and return a new object."""
+        return MoveParams(
+            max_speed=max_speed if max_speed is not None else self.max_speed,
+            acceleration=acceleration
+            if acceleration is not None
+            else self.acceleration,
+            max_speed_discont=max_speed_discont
+            if max_speed_discont is not None
+            else self.max_speed_discont,
+        )
+
+
+@dataclass
+class AxisParams:
+    """Axis Parameters."""
+
+    run_current: float
+    hold_current: float
+    move_params: MoveParams
+
+
+@dataclass
+class StallGuardParams:
+    """StallGuard Parameters."""
+
+    axis: StackerAxis
+    enabled: bool
+    threshold: int
+
+
+class MoveResult(str, Enum):
+    """The result of a move command."""
+
+    NO_ERROR = "ok"
+    STALL_ERROR = "stall"
+    UNKNOWN_ERROR = "unknown"
+
+
+class MeasurementKind(Enum):
+    """The kind of measurement to request."""
+
+    HISTOGRAM = 0
+
+
+class SpadMapID(Enum):
+    """The spad map id for the TOF sensor."""
+
+    SPAD_MAP_ID_1 = 1
+    # 3x3 macro 1 mode 33°x47° FoV off center
+    SPAD_MAP_ID_2 = 2
+    # 3x3 macro 2 mode 33°x47° FoV
+    SPAD_MAP_ID_3 = 3
+    # 3x3 wide mode 41°x52° FoV
+    SPAD_MAP_ID_6 = 6
+    # 3x3 mode 33°x32° FoV, checkerboard
+    SPAD_MAP_ID_11 = 11
+    # 3x3 mode 33°x32° FoV, inverted checkerboard
+    SPAD_MAP_ID_12 = 12
+    # User defined mode, single measurement mode
+    SPAD_MAP_ID_14 = 14
+
+
+class ActiveRange(Enum):
+    """The active range for the TOF sensor."""
+
+    NOT_SUPPORTED = 0
+    SHORT_RANGE = 0x6E
+    LONG_RANGE = 0x6F
+
+
+@dataclass
+class TOFMeasurement:
+    """The start measurement data."""
+
+    sensor: TOFSensor
+    kind: MeasurementKind
+    cancelled: bool
+    total_bytes: int
+
+
+@dataclass
+class TOFMeasurementFrame:
+    """Stacker TOF measurement frame."""
+
+    sensor: TOFSensor
+    frame_id: int
+    data: bytes
+
+
+@dataclass
+class TOFMeasurementResult:
+    """Stacker TOF measurement result."""
+
+    sensor: TOFSensor
+    kind: MeasurementKind
+    bins: Dict[int, List[int]]
+
+
+@dataclass
+class TOFConfiguration:
+    """Stacker TOF configuration."""
+
+    sensor: TOFSensor
+    spad_map_id: SpadMapID
+    active_range: Optional[ActiveRange]
+    kilo_iterations: Optional[int]
+    report_period_ms: Optional[int]
+    histogram_dump: Optional[bool]