opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/drivers/flex_stacker/abstract.py

@@ -0,0 +1,89 @@
+from typing import Protocol
+
+from .types import (
+    StackerAxis,
+    PlatformStatus,
+    Direction,
+    MoveParams,
+    StackerInfo,
+    LEDColor,
+)
+
+
+class AbstractStackerDriver(Protocol):
+    """Protocol for the Stacker driver."""
+
+    async def connect(self) -> None:
+        """Connect to stacker."""
+        ...
+
+    async def disconnect(self) -> None:
+        """Disconnect from stacker."""
+        ...
+
+    async def is_connected(self) -> bool:
+        """Check connection to stacker."""
+        ...
+
+    async def update_firmware(self, firmware_file_path: str) -> None:
+        """Updates the firmware on the device."""
+        ...
+
+    async def get_device_info(self) -> StackerInfo:
+        """Get Device Info."""
+        ...
+
+    async def set_serial_number(self, sn: str) -> bool:
+        """Set Serial Number."""
+        ...
+
+    async def stop_motors(self) -> bool:
+        """Stop all motor movement."""
+        ...
+
+    async def get_limit_switch(self, axis: StackerAxis, direction: Direction) -> bool:
+        """Get limit switch status.
+
+        :return: True if limit switch is triggered, False otherwise
+        """
+        ...
+
+    async def get_platform_sensor(self, direction: Direction) -> bool:
+        """Get platform sensor status.
+
+        :return: True if platform is present, False otherwise
+        """
+        ...
+
+    async def get_platform_status(self) -> PlatformStatus:
+        """Get platform status."""
+        ...
+
+    async def get_hopper_door_closed(self) -> bool:
+        """Get whether or not door is closed.
+
+        :return: True if door is closed, False otherwise
+        """
+        ...
+
+    async def move_in_mm(
+        self, axis: StackerAxis, distance: float, params: MoveParams | None = None
+    ) -> bool:
+        """Move axis."""
+        ...
+
+    async def move_to_limit_switch(
+        self, axis: StackerAxis, direction: Direction, params: MoveParams | None = None
+    ) -> bool:
+        """Move until limit switch is triggered."""
+        ...
+
+    async def home_axis(self, axis: StackerAxis, direction: Direction) -> bool:
+        """Home axis."""
+        ...
+
+    async def set_led(
+        self, power: float, color: LEDColor | None = None, external: bool | None = None
+    ) -> bool:
+        """Set LED color of status bar."""
+        ...

opentrons/drivers/flex_stacker/driver.py

@@ -0,0 +1,260 @@
+import asyncio
+import re
+from typing import Optional
+
+from opentrons.drivers.command_builder import CommandBuilder
+from opentrons.drivers.asyncio.communication import AsyncResponseSerialConnection
+
+from .abstract import AbstractStackerDriver
+from .types import (
+    GCODE,
+    StackerAxis,
+    PlatformStatus,
+    Direction,
+    StackerInfo,
+    HardwareRevision,
+    MoveParams,
+    LimitSwitchStatus,
+    LEDColor,
+)
+
+
+FS_BAUDRATE = 115200
+DEFAULT_FS_TIMEOUT = 40
+FS_ACK = "OK\n"
+FS_ERROR_KEYWORD = "err"
+FS_ASYNC_ERROR_ACK = "async"
+DEFAULT_COMMAND_RETRIES = 0
+GCODE_ROUNDING_PRECISION = 2
+
+
+class FlexStackerDriver(AbstractStackerDriver):
+    """FLEX Stacker driver."""
+
+    @classmethod
+    def parse_device_info(cls, response: str) -> StackerInfo:
+        """Parse stacker info."""
+        # TODO: Validate serial number format once established
+        _RE = re.compile(
+            f"^{GCODE.DEVICE_INFO} FW:(?P<fw>\\S+) HW:Opentrons-flex-stacker-(?P<hw>\\S+) SerialNo:(?P<sn>\\S+)$"
+        )
+        m = _RE.match(response)
+        if not m:
+            raise ValueError(f"Incorrect Response for device info: {response}")
+        return StackerInfo(
+            m.group("fw"), HardwareRevision(m.group("hw")), m.group("sn")
+        )
+
+    @classmethod
+    def parse_limit_switch_status(cls, response: str) -> LimitSwitchStatus:
+        """Parse limit switch statuses."""
+        field_names = LimitSwitchStatus.get_fields()
+        pattern = r"\s".join([rf"{name}:(?P<{name}>\d)" for name in field_names])
+        _RE = re.compile(f"^{GCODE.GET_LIMIT_SWITCH} {pattern}$")
+        m = _RE.match(response)
+        if not m:
+            raise ValueError(f"Incorrect Response for limit switch status: {response}")
+        return LimitSwitchStatus(*(bool(int(m.group(name))) for name in field_names))
+
+    @classmethod
+    def parse_platform_sensor_status(cls, response: str) -> PlatformStatus:
+        """Parse platform statuses."""
+        field_names = PlatformStatus.get_fields()
+        pattern = r"\s".join([rf"{name}:(?P<{name}>\d)" for name in field_names])
+        _RE = re.compile(f"^{GCODE.GET_PLATFORM_SENSOR} {pattern}$")
+        m = _RE.match(response)
+        if not m:
+            raise ValueError(f"Incorrect Response for platform status: {response}")
+        return PlatformStatus(*(bool(int(m.group(name))) for name in field_names))
+
+    @classmethod
+    def parse_door_closed(cls, response: str) -> bool:
+        """Parse door closed."""
+        _RE = re.compile(r"^M122 D:(\d)$")
+        match = _RE.match(response)
+        if not match:
+            raise ValueError(f"Incorrect Response for door closed: {response}")
+        return bool(int(match.group(1)))
+
+    @classmethod
+    def append_move_params(
+        cls, command: CommandBuilder, params: MoveParams | None
+    ) -> CommandBuilder:
+        """Append move params."""
+        if params is not None:
+            if params.max_speed is not None:
+                command.add_float("V", params.max_speed, GCODE_ROUNDING_PRECISION)
+            if params.acceleration is not None:
+                command.add_float("A", params.acceleration, GCODE_ROUNDING_PRECISION)
+            if params.max_speed_discont is not None:
+                command.add_float(
+                    "D", params.max_speed_discont, GCODE_ROUNDING_PRECISION
+                )
+        return command
+
+    @classmethod
+    async def create(
+        cls, port: str, loop: Optional[asyncio.AbstractEventLoop]
+    ) -> "FlexStackerDriver":
+        """Create a FLEX Stacker driver."""
+        connection = await AsyncResponseSerialConnection.create(
+            port=port,
+            baud_rate=FS_BAUDRATE,
+            timeout=DEFAULT_FS_TIMEOUT,
+            number_of_retries=DEFAULT_COMMAND_RETRIES,
+            ack=FS_ACK,
+            loop=loop,
+            error_keyword=FS_ERROR_KEYWORD,
+            async_error_ack=FS_ASYNC_ERROR_ACK,
+        )
+        return cls(connection)
+
+    def __init__(self, connection: AsyncResponseSerialConnection) -> None:
+        """
+        Constructor
+
+        Args:
+            connection: Connection to the FLEX Stacker
+        """
+        self._connection = connection
+
+    async def connect(self) -> None:
+        """Connect to stacker."""
+        await self._connection.open()
+
+    async def disconnect(self) -> None:
+        """Disconnect from stacker."""
+        await self._connection.close()
+
+    async def is_connected(self) -> bool:
+        """Check connection to stacker."""
+        return await self._connection.is_open()
+
+    async def get_device_info(self) -> StackerInfo:
+        """Get Device Info."""
+        response = await self._connection.send_command(
+            GCODE.DEVICE_INFO.build_command()
+        )
+        await self._connection.send_command(GCODE.GET_RESET_REASON.build_command())
+        return self.parse_device_info(response)
+
+    async def set_serial_number(self, sn: str) -> bool:
+        """Set Serial Number."""
+        # TODO: validate the serial number format
+        resp = await self._connection.send_command(
+            GCODE.SET_SERIAL_NUMBER.build_command().add_element(sn)
+        )
+        if not re.match(rf"^{GCODE.SET_SERIAL_NUMBER}$", resp):
+            raise ValueError(f"Incorrect Response for set serial number: {resp}")
+        return True
+
+    async def stop_motors(self) -> bool:
+        """Stop all motor movement."""
+        resp = await self._connection.send_command(GCODE.STOP_MOTORS.build_command())
+        if not re.match(rf"^{GCODE.STOP_MOTORS}$", resp):
+            raise ValueError(f"Incorrect Response for stop motors: {resp}")
+        return True
+
+    async def get_limit_switch(self, axis: StackerAxis, direction: Direction) -> bool:
+        """Get limit switch status.
+
+        :return: True if limit switch is triggered, False otherwise
+        """
+        response = await self.get_limit_switches_status()
+        return response.get(axis, direction)
+
+    async def get_limit_switches_status(self) -> LimitSwitchStatus:
+        """Get limit switch statuses for all axes."""
+        response = await self._connection.send_command(
+            GCODE.GET_LIMIT_SWITCH.build_command()
+        )
+        return self.parse_limit_switch_status(response)
+
+    async def get_platform_sensor(self, direction: Direction) -> bool:
+        """Get platform sensor at one direction."""
+        response = await self.get_platform_status()
+        return response.get(direction)
+
+    async def get_platform_status(self) -> PlatformStatus:
+        """Get platform sensor status.
+
+        :return: True if platform is detected, False otherwise
+        """
+        response = await self._connection.send_command(
+            GCODE.GET_PLATFORM_SENSOR.build_command()
+        )
+        return self.parse_platform_sensor_status(response)
+
+    async def get_hopper_door_closed(self) -> bool:
+        """Get whether or not door is closed.
+
+        :return: True if door is closed, False otherwise
+        """
+        response = await self._connection.send_command(
+            GCODE.GET_DOOR_SWITCH.build_command()
+        )
+        return self.parse_door_closed(response)
+
+    async def move_in_mm(
+        self, axis: StackerAxis, distance: float, params: MoveParams | None = None
+    ) -> bool:
+        """Move axis."""
+        command = self.append_move_params(
+            GCODE.MOVE_TO.build_command().add_float(
+                axis.name, distance, GCODE_ROUNDING_PRECISION
+            ),
+            params,
+        )
+        resp = await self._connection.send_command(command)
+        if not re.match(rf"^{GCODE.MOVE_TO}$", resp):
+            raise ValueError(f"Incorrect Response for move to: {resp}")
+        return True
+
+    async def move_to_limit_switch(
+        self, axis: StackerAxis, direction: Direction, params: MoveParams | None = None
+    ) -> bool:
+        """Move until limit switch is triggered."""
+        command = self.append_move_params(
+            GCODE.MOVE_TO_SWITCH.build_command().add_int(axis.name, direction.value),
+            params,
+        )
+        resp = await self._connection.send_command(command)
+        if not re.match(rf"^{GCODE.MOVE_TO_SWITCH}$", resp):
+            raise ValueError(f"Incorrect Response for move to switch: {resp}")
+        return True
+
+    async def home_axis(self, axis: StackerAxis, direction: Direction) -> bool:
+        """Home axis."""
+        resp = await self._connection.send_command(
+            GCODE.HOME_AXIS.build_command().add_int(axis.name, direction.value)
+        )
+        if not re.match(rf"^{GCODE.HOME_AXIS}$", resp):
+            raise ValueError(f"Incorrect Response for home axis: {resp}")
+        return True
+
+    async def set_led(
+        self, power: float, color: LEDColor | None = None, external: bool | None = None
+    ) -> bool:
+        """Set LED color.
+
+        :param power: Power of the LED (0-1.0), 0 is off, 1 is full power
+        :param color: Color of the LED
+        :param external: True if external LED, False if internal LED
+        """
+        power = max(0, min(power, 1.0))
+        command = GCODE.SET_LED.build_command().add_float(
+            "P", power, GCODE_ROUNDING_PRECISION
+        )
+        if color is not None:
+            command.add_int("C", color.value)
+        if external is not None:
+            command.add_int("E", external)
+        resp = await self._connection.send_command(command)
+        if not re.match(rf"^{GCODE.SET_LED}$", resp):
+            raise ValueError(f"Incorrect Response for set led: {resp}")
+        return True
+
+    async def update_firmware(self, firmware_file_path: str) -> None:
+        """Updates the firmware on the device."""
+        # TODO: Implement firmware update
+        pass

opentrons/drivers/flex_stacker/simulator.py

@@ -0,0 +1,109 @@
+from typing import Optional
+
+from opentrons.util.async_helpers import ensure_yield
+
+from .abstract import AbstractStackerDriver
+from .types import (
+    StackerAxis,
+    PlatformStatus,
+    Direction,
+    StackerInfo,
+    HardwareRevision,
+    MoveParams,
+    LimitSwitchStatus,
+)
+
+
+class SimulatingDriver(AbstractStackerDriver):
+    """FLEX Stacker driver simulator."""
+
+    def __init__(self, serial_number: Optional[str] = None) -> None:
+        self._sn = serial_number or "dummySerialFS"
+        self._limit_switch_status = LimitSwitchStatus(False, False, False, False, False)
+        self._platform_sensor_status = PlatformStatus(False, False)
+        self._door_closed = True
+
+    def set_limit_switch(self, status: LimitSwitchStatus) -> bool:
+        self._limit_switch_status = status
+        return True
+
+    def set_platform_sensor(self, status: PlatformStatus) -> bool:
+        self._platform_sensor_status = status
+        return True
+
+    def set_door_closed(self, door_closed: bool) -> bool:
+        self._door_closed = door_closed
+        return True
+
+    @ensure_yield
+    async def connect(self) -> None:
+        """Connect to stacker."""
+        pass
+
+    @ensure_yield
+    async def disconnect(self) -> None:
+        """Disconnect from stacker."""
+        pass
+
+    @ensure_yield
+    async def is_connected(self) -> bool:
+        """Check connection to stacker."""
+        return True
+
+    @ensure_yield
+    async def get_device_info(self) -> StackerInfo:
+        """Get Device Info."""
+        return StackerInfo(fw="stacker-fw", hw=HardwareRevision.EVT, sn=self._sn)
+
+    @ensure_yield
+    async def set_serial_number(self, sn: str) -> bool:
+        """Set Serial Number."""
+        return True
+
+    @ensure_yield
+    async def stop_motor(self) -> bool:
+        """Stop motor movement."""
+        return True
+
+    @ensure_yield
+    async def get_limit_switch(self, axis: StackerAxis, direction: Direction) -> bool:
+        """Get limit switch status.
+
+        :return: True if limit switch is triggered, False otherwise
+        """
+        return self._limit_switch_status.get(axis, direction)
+
+    @ensure_yield
+    async def get_limit_switches_status(self) -> LimitSwitchStatus:
+        """Get limit switch statuses for all axes."""
+        return self._limit_switch_status
+
+    @ensure_yield
+    async def get_platform_sensor_status(self) -> PlatformStatus:
+        """Get platform sensor status.
+
+        :return: True if platform is detected, False otherwise
+        """
+        return self._platform_sensor_status
+
+    @ensure_yield
+    async def get_hopper_door_closed(self) -> bool:
+        """Get whether or not door is closed.
+
+        :return: True if door is closed, False otherwise
+        """
+        return self._door_closed
+
+    @ensure_yield
+    async def move_in_mm(
+        self, axis: StackerAxis, distance: float, params: MoveParams | None = None
+    ) -> bool:
+        """Move axis."""
+        return True
+
+    @ensure_yield
+    async def move_to_limit_switch(
+        self, axis: StackerAxis, direction: Direction, params: MoveParams | None = None
+    ) -> bool:
+        """Move until limit switch is triggered."""
+        return True

opentrons/drivers/flex_stacker/types.py

@@ -0,0 +1,138 @@
+from enum import Enum
+from dataclasses import dataclass, fields
+from typing import List
+
+from opentrons.drivers.command_builder import CommandBuilder
+
+
+class GCODE(str, Enum):
+
+    MOVE_TO = "G0"
+    MOVE_TO_SWITCH = "G5"
+    HOME_AXIS = "G28"
+    STOP_MOTORS = "M0"
+    GET_RESET_REASON = "M114"
+    DEVICE_INFO = "M115"
+    GET_LIMIT_SWITCH = "M119"
+    SET_LED = "M200"
+    GET_PLATFORM_SENSOR = "M121"
+    GET_DOOR_SWITCH = "M122"
+    SET_SERIAL_NUMBER = "M996"
+    ENTER_BOOTLOADER = "dfu"
+
+    def build_command(self) -> CommandBuilder:
+        """Build command."""
+        return CommandBuilder().add_gcode(self)
+
+
+STACKER_VID = 0x483
+STACKER_PID = 0xEF24
+STACKER_FREQ = 115200
+
+
+class HardwareRevision(Enum):
+    """Hardware Revision."""
+
+    NFF = "nff"
+    EVT = "a1"
+
+
+@dataclass
+class StackerInfo:
+    """Stacker Info."""
+
+    fw: str
+    hw: HardwareRevision
+    sn: str
+
+
+class StackerAxis(Enum):
+    """Stacker Axis."""
+
+    X = "X"
+    Z = "Z"
+    L = "L"
+
+    def __str__(self) -> str:
+        """Name."""
+        return self.name
+
+
+class LEDColor(Enum):
+    """Stacker LED Color."""
+
+    WHITE = 0
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+
+
+class Direction(Enum):
+    """Direction."""
+
+    RETRACT = 0  # negative
+    EXTENT = 1  # positive
+
+    def __str__(self) -> str:
+        """Convert to tag for clear logging."""
+        return "negative" if self == Direction.RETRACT else "positive"
+
+    def opposite(self) -> "Direction":
+        """Get opposite direction."""
+        return Direction.EXTENT 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
+
+
+@dataclass
+class LimitSwitchStatus:
+    """Stacker Limit Switch Statuses."""
+
+    XE: bool
+    XR: bool
+    ZE: bool
+    ZR: bool
+    LR: bool
+
+    @classmethod
+    def get_fields(cls) -> List[str]:
+        """Get fields."""
+        return [f.name for f in fields(cls)]
+
+    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
+        if axis == StackerAxis.Z:
+            return self.ZE if direction == Direction.EXTENT else self.ZR
+        if direction == Direction.EXTENT:
+            raise ValueError("Latch does not have extent limit switch")
+        return self.LR
+
+
+@dataclass
+class PlatformStatus:
+    """Stacker Platform Statuses."""
+
+    E: bool
+    R: bool
+
+    @classmethod
+    def get_fields(cls) -> List[str]:
+        """Get fields."""
+        return [f.name for f in fields(cls)]
+
+    def get(self, direction: Direction) -> bool:
+        """Get platform status."""
+        return self.E if direction == Direction.EXTENT else self.R
+
+
+@dataclass
+class MoveParams:
+    """Move Parameters."""
+
+    max_speed: float | None = None
+    acceleration: float | None = None
+    max_speed_discont: float | None = None

opentrons/drivers/heater_shaker/driver.py

@@ -6,7 +6,10 @@ import asyncio
 from typing import Optional, Dict
 from opentrons.drivers import utils
 from opentrons.drivers.command_builder import CommandBuilder
-from opentrons.drivers.asyncio.communication import AsyncResponseSerialConnection
+from opentrons.drivers.asyncio.communication import (
+    AsyncResponseSerialConnection,
+    UnhandledGcode,
+)
 from opentrons.drivers.heater_shaker.abstract import AbstractHeaterShakerDriver
 from opentrons.drivers.types import Temperature, RPM, HeaterShakerLabwareLatchStatus
 
@@ -23,6 +26,7 @@ class GCODE(str, Enum):
     CLOSE_LABWARE_LATCH = "M243"
     GET_LABWARE_LATCH_STATE = "M241"
     DEACTIVATE_HEATER = "M106"
+    GET_RESET_REASON = "M114"
 
 
 HS_BAUDRATE = 115200
@@ -166,12 +170,23 @@ class HeaterShakerDriver(AbstractHeaterShakerDriver):
 
     async def get_device_info(self) -> Dict[str, str]:
         """Send get-device-info command"""
-        c = CommandBuilder(terminator=HS_COMMAND_TERMINATOR).add_gcode(
+        device_info = CommandBuilder(terminator=HS_COMMAND_TERMINATOR).add_gcode(
             gcode=GCODE.GET_VERSION
         )
         response = await self._connection.send_command(
-            command=c, retries=DEFAULT_COMMAND_RETRIES
+            command=device_info, retries=DEFAULT_COMMAND_RETRIES
+        )
+
+        reset_reason = CommandBuilder(terminator=HS_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.GET_RESET_REASON
         )
+        try:
+            await self._connection.send_command(
+                command=reset_reason, retries=DEFAULT_COMMAND_RETRIES
+            )
+        except UnhandledGcode:
+            pass
+
         return utils.parse_hs_device_information(device_info_string=response)
 
     async def enter_programming_mode(self) -> None:

opentrons/drivers/temp_deck/driver.py

@@ -17,7 +17,7 @@ from enum import Enum
 from opentrons.drivers import utils
 from opentrons.drivers.types import Temperature
 from opentrons.drivers.command_builder import CommandBuilder
-from opentrons.drivers.asyncio.communication import SerialConnection
+from opentrons.drivers.asyncio.communication import SerialConnection, UnhandledGcode
 from opentrons.drivers.temp_deck.abstract import AbstractTempDeckDriver
 
 log = logging.getLogger(__name__)
@@ -31,6 +31,7 @@ class GCODE(str, Enum):
     GET_TEMP = "M105"
     SET_TEMP = "M104"
     DEVICE_INFO = "M115"
+    GET_RESET_REASON = "M114"
     DISENGAGE = "M18"
     PROGRAMMING_MODE = "dfu"
 
@@ -154,10 +155,19 @@ class TempDeckDriver(AbstractTempDeckDriver):
         Example input from Temp-Deck's serial response:
             "serial:aa11bb22 model:aa11bb22 version:aa11bb22"
         """
-        c = CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR).add_gcode(
+        device_info = CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR).add_gcode(
             gcode=GCODE.DEVICE_INFO
         )
-        response = await self._send_command(command=c)
+        response = await self._send_command(command=device_info)
+
+        reset_reason = CommandBuilder(
+            terminator=TEMP_DECK_COMMAND_TERMINATOR
+        ).add_gcode(gcode=GCODE.GET_RESET_REASON)
+        try:
+            await self._send_command(command=reset_reason)
+        except UnhandledGcode:
+            pass
+
         return utils.parse_device_information(device_info_string=response)
 
     async def enter_programming_mode(self) -> None: