opentrons 8.6.0__py3-none-any.whl

opentrons/drivers/smoothie_drivers/errors.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+
+class SmoothieError(Exception):
+    def __init__(
+        self, ret_code: Optional[str] = None, command: Optional[str] = None
+    ) -> None:
+        self.ret_code = ret_code or ""
+        self.command = command
+        super().__init__()
+
+    def __repr__(self) -> str:
+        return f"<SmoothieError: {self.ret_code} from {self.command}>"
+
+    def __str__(self) -> str:
+        return f"SmoothieError: {self.command} returned {self.ret_code}"
+
+
+class SmoothieAlarm(Exception):
+    def __init__(
+        self, ret_code: Optional[str] = None, command: Optional[str] = None
+    ) -> None:
+        self.ret_code = ret_code
+        self.command = command
+        super().__init__()
+
+    def __repr__(self) -> str:
+        return f"<SmoothieAlarm: {self.ret_code} from {self.command}>"
+
+    def __str__(self) -> str:
+        return f"SmoothieAlarm: {self.command} returned {self.ret_code}"
+
+
+class TipProbeError(SmoothieAlarm):
+    def __init__(
+        self, ret_code: Optional[str] = None, command: Optional[str] = None
+    ) -> None:
+        self.ret_code = ret_code
+        self.command = command
+        super().__init__(ret_code, command)
+
+    def __repr__(self) -> str:
+        return f"<TipProbeError: {self.ret_code} from {self.command}"
+
+    def __str__(self) -> str:
+        return (
+            "Tip probe could not complete: the switch was never touched. "
+            "This may be because there is no tip on the pipette."
+        )

opentrons/drivers/smoothie_drivers/parse_utils.py

@@ -0,0 +1,143 @@
+import logging
+from typing import Dict
+
+from opentrons.drivers.smoothie_drivers.constants import AXES, GCODE_ROUNDING_PRECISION
+from opentrons.drivers.utils import (
+    parse_key_values,
+    parse_number,
+    parse_optional_number,
+    ParseError,
+)
+
+
+log = logging.getLogger(__name__)
+
+
+def parse_position_response(raw_axis_values: str) -> Dict[str, float]:
+    """
+    Parse position response.
+
+    Args:
+        raw_axis_values: a string containing axis:value
+
+    Returns:
+        dictionary of axis to position.
+    """
+    parsed_values = parse_key_values(raw_axis_values)
+    if len(parsed_values) < 6:
+        raise ParseError(
+            error_message="Unexpected response in _parse_position_response",
+            parse_source=raw_axis_values,
+        )
+
+    data = {
+        k.title(): parse_number(v, GCODE_ROUNDING_PRECISION)
+        for k, v in parsed_values.items()
+    }
+    return data
+
+
+def parse_instrument_data(smoothie_response: str) -> Dict[str, bytearray]:
+    """
+    Parse instrument data.
+
+    Args:
+        smoothie_response: A string containing a mount prefix (L or R) followed by :
+            and a hex string.
+
+    Returns:
+        mapping of the mount prefix to the hex string.
+    """
+    try:
+        items = smoothie_response.split("\n")[0].strip().split(":")
+        mount = items[0]
+        if mount not in {"L", "R"}:
+            raise ParseError(
+                error_message=f"Invalid mount '{mount}'", parse_source=smoothie_response
+            )
+        # data received from Smoothieware is stringified HEX values
+        # because of how Smoothieware handles GCODE messages
+        data = bytearray.fromhex(items[1])
+    except (ValueError, IndexError, TypeError, AttributeError):
+        raise ParseError(
+            error_message="Unexpected argument to parse_instrument_data",
+            parse_source=smoothie_response,
+        )
+    return {mount: data}
+
+
+def byte_array_to_ascii_string(byte_array: bytearray) -> str:
+    """
+    Convert byte array to ascii string.
+
+    Args:
+        byte_array: a byte array
+
+    Returns:
+        String
+
+    """
+    # remove trailing null characters
+    try:
+        for c in [b"\x00", b"\xFF"]:
+            if c in byte_array:
+                byte_array = byte_array[: byte_array.index(c)]
+        res = byte_array.decode()
+    except (ValueError, TypeError, AttributeError):
+        log.exception("Unexpected argument to _byte_array_to_ascii_string:")
+        raise ParseError(
+            error_message="Unexpected argument to byte_array_to_ascii_string",
+            parse_source=byte_array.decode(),
+        )
+    return res
+
+
+def parse_switch_values(raw_switch_values: str) -> Dict[str, bool]:
+    if not raw_switch_values or not isinstance(raw_switch_values, str):
+        raise ParseError(
+            error_message="Unexpected argument to parse_switch_values",
+            parse_source=raw_switch_values,
+        )
+
+    # probe has a space after it's ":" for some reason
+    if "Probe: " in raw_switch_values:
+        raw_switch_values = raw_switch_values.replace("Probe: ", "Probe:")
+
+    parsed_values = parse_key_values(raw_switch_values)
+    res = {
+        k.title(): bool(parse_optional_number(v, rounding_val=GCODE_ROUNDING_PRECISION))
+        for (k, v) in parsed_values.items()
+        if any(n in k for n in ["max", "Probe"])
+    }
+    # remove the extra "_max" character from each axis key in the dict
+    res = {key.split("_")[0]: val for key, val in res.items()}
+    if len((list(AXES) + ["Probe"]) & res.keys()) != 7:
+        raise ParseError(
+            error_message="Unexpected argument to parse_switch_values",
+            parse_source=raw_switch_values,
+        )
+    return res
+
+
+def parse_homing_status_values(raw_homing_status_values: str) -> Dict[str, bool]:
+    """
+    Parse the Smoothieware response to a G28.6 command (homing-status)
+    A "1" means it has been homed, and "0" means it has not been homed
+
+    Example response after homing just X axis:
+    "X:1 Y:0 Z:0 A:0 B:0 C:0"
+
+    returns: dict
+        Key is axis, value is True if the axis needs to be homed
+    """
+    parsed_values = parse_key_values(raw_homing_status_values)
+    res = {
+        k.title(): bool(parse_number(v, GCODE_ROUNDING_PRECISION))
+        for k, v in parsed_values.items()
+    }
+    if len(list(AXES) & res.keys()) != 6:
+        raise ParseError(
+            error_message="Unexpected argument to parse_homing_status_values",
+            parse_source=raw_homing_status_values,
+        )
+    return res

opentrons/drivers/smoothie_drivers/simulator.py

@@ -0,0 +1,99 @@
+from typing import Optional, Dict, Union
+
+from opentrons.drivers.smoothie_drivers.constants import (
+    HOMED_POSITION,
+    Y_BOUND_OVERRIDE,
+    DISABLE_AXES,
+    AXES,
+)
+from opentrons.drivers.types import MoveSplits
+
+
+class SimulatingDriver:
+    def __init__(self) -> None:
+        self._steps_per_mm: Dict[str, float] = {}
+        self._homed_flags: Dict[str, bool] = {}
+
+    @property
+    def homed_flags(self) -> Dict[str, bool]:
+        return self._homed_flags
+
+    async def home(self, axis: str = AXES, disabled: str = DISABLE_AXES) -> None:
+        for ax in axis:
+            self._homed_flags[ax] = True
+
+    async def _smoothie_reset(self) -> None:
+        self._homed_flags.clear()
+
+    async def read_pipette_id(self, mount: str) -> Optional[str]:
+        pass
+
+    async def read_pipette_model(self, mount: str) -> Optional[str]:
+        pass
+
+    async def write_pipette_id(self, mount: str, data_string: str) -> None:
+        pass
+
+    async def write_pipette_model(self, mount: str, data_string: str) -> None:
+        pass
+
+    # def _send_command(self, command, timeout=None):
+    #     pass
+
+    def turn_on_blue_button_light(self) -> None:
+        pass
+
+    def turn_on_red_button_light(self) -> None:
+        pass
+
+    async def update_pipette_config(
+        self, axis: str, data: Dict[str, float]
+    ) -> Dict[str, Dict[str, float]]:
+        """
+        Updates the following configs for a given pipette mount based on
+        the detected pipette type:
+        - homing positions M365.0
+        - Max Travel M365.1
+        - endstop debounce M365.2 (NOT for zprobe debounce)
+        - retract from endstop distance M365.3
+        """
+        return {}
+
+    @property
+    def current(self) -> Dict[str, float]:
+        return {}
+
+    @property
+    def speed(self) -> None:
+        pass
+
+    @property
+    def steps_per_mm(self) -> Dict[str, float]:
+        return self._steps_per_mm
+
+    # @steps_per_mm.setter
+    # def steps_per_mm(self, axis, mm):
+    #     # Keep track of any updates to the steps per mm per axis
+    #     self._steps_per_mm[axis] = mm
+
+    async def update_steps_per_mm(self, data: Union[Dict[str, float], str]) -> None:
+        pass
+
+    def configure_splits_for(self, config: MoveSplits) -> None:
+        pass
+
+    def set_dwelling_current(self, settings: Dict[str, float]) -> None:
+        pass
+
+    def set_acceleration(self, settings: Dict[str, float]) -> None:
+        pass
+
+    @property
+    def homed_position(self) -> Dict[str, float]:
+        return HOMED_POSITION.copy()
+
+    @property
+    def axis_bounds(self) -> Dict[str, float]:
+        position = HOMED_POSITION.copy()
+        position["Y"] = Y_BOUND_OVERRIDE
+        return position

opentrons/drivers/smoothie_drivers/types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Dict, cast
+
+from opentrons.config.types import AxisDict
+
+AxisSettingType = Dict[str, float]
+
+
+@dataclass
+class AxisCurrentSettings:
+    now: AxisSettingType
+    saved: AxisSettingType
+
+    def __init__(self, val: AxisDict) -> None:
+        self.now = cast(AxisSettingType, val.copy())
+        self.saved = cast(AxisSettingType, val.copy())

opentrons/drivers/temp_deck/__init__.py

@@ -0,0 +1,10 @@
+from .driver import TempDeckDriver
+from .abstract import AbstractTempDeckDriver
+from .simulator import SimulatingDriver
+
+
+__all__ = [
+    "TempDeckDriver",
+    "AbstractTempDeckDriver",
+    "SimulatingDriver",
+]

opentrons/drivers/temp_deck/abstract.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+from typing import Dict
+
+from opentrons.drivers.types import Temperature
+
+
+class AbstractTempDeckDriver(ABC):
+    @abstractmethod
+    async def connect(self) -> None:
+        ...
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        ...
+
+    @abstractmethod
+    async def is_connected(self) -> bool:
+        ...
+
+    @abstractmethod
+    async def deactivate(self) -> None:
+        ...
+
+    @abstractmethod
+    async def set_temperature(self, celsius: float) -> None:
+        ...
+
+    @abstractmethod
+    async def get_temperature(self) -> Temperature:
+        ...
+
+    @abstractmethod
+    async def get_device_info(self) -> Dict[str, str]:
+        """
+        Queries Temp-Deck for its build version, model, and serial number
+
+        returns: dict
+            Where keys are the strings 'version', 'model', and 'serial',
+            and each value is a string identifier
+
+            {
+                'serial': '1aa11bb22',
+                'model': '1aa11bb22',
+                'version': '1aa11bb22'
+            }
+
+        Example input from Temp-Deck's serial response:
+            "serial:aa11bb22 model:aa11bb22 version:aa11bb22"
+        """
+        ...
+
+    @abstractmethod
+    async def enter_programming_mode(self) -> None:
+        ...

opentrons/drivers/temp_deck/driver.py

@@ -0,0 +1,197 @@
+"""
+- Driver is responsible for providing an interface for the temp-deck
+- Driver is the only system component that knows about the temp-deck's GCODES
+  or how the temp-deck communications
+
+- Driver is NOT responsible interpreting the temperatures or states in any way
+  or knowing anything about what the device is being used for
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Dict, Optional
+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, UnhandledGcode
+from opentrons.drivers.temp_deck.abstract import AbstractTempDeckDriver
+
+log = logging.getLogger(__name__)
+
+DEFAULT_TEMP_DECK_TIMEOUT = 1
+
+DEFAULT_COMMAND_RETRIES = 3
+
+
+class GCODE(str, Enum):
+    GET_TEMP = "M105"
+    SET_TEMP = "M104"
+    DEVICE_INFO = "M115"
+    GET_RESET_REASON = "M114"
+    DISENGAGE = "M18"
+    PROGRAMMING_MODE = "dfu"
+
+
+TEMP_DECK_BAUDRATE = 115200
+
+TEMP_DECK_COMMAND_TERMINATOR = "\r\n\r\n"
+TEMP_DECK_ACK = "ok\r\nok\r\n"
+
+
+class TempDeckError(Exception):
+    pass
+
+
+class TempDeckDriver(AbstractTempDeckDriver):
+    @classmethod
+    async def create(
+        cls, port: str, loop: Optional[asyncio.AbstractEventLoop] = None
+    ) -> TempDeckDriver:
+        """
+        Create a temp deck driver.
+
+        Args:
+            port: port or url of temp deck
+            loop: optional event loop
+
+        Returns: driver
+        """
+        connection = await SerialConnection.create(
+            port=port,
+            baud_rate=TEMP_DECK_BAUDRATE,
+            timeout=DEFAULT_TEMP_DECK_TIMEOUT,
+            ack=TEMP_DECK_ACK,
+            loop=loop,
+            reset_buffer_before_write=False,
+        )
+        return cls(connection=connection)
+
+    def __init__(self, connection: SerialConnection) -> None:
+        """
+        Construct a temp deck driver
+
+        Args:
+            connection: Connection to the temp deck
+        """
+        self._connection = connection
+
+    async def connect(self) -> None:
+        """Connect to the temp deck."""
+        await self._connection.open()
+
+    async def disconnect(self) -> None:
+        """Disconnect from temp deck"""
+        await self._connection.close()
+
+    async def is_connected(self) -> bool:
+        """Check connected state"""
+        return await self._connection.is_open()
+
+    async def deactivate(self) -> None:
+        """
+        Send disengage command to temp deck
+
+        Returns: None
+        """
+        c = CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.DISENGAGE
+        )
+        await self._send_command(command=c)
+
+    async def set_temperature(self, celsius: float) -> None:
+        """
+        Send a set temperate command to temp deck
+
+        Args:
+            celsius: the target temperature
+
+        Returns: None
+        """
+        c = (
+            CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR)
+            .add_gcode(gcode=GCODE.SET_TEMP)
+            .add_float(
+                prefix="S",
+                value=celsius,
+                precision=utils.TEMPDECK_GCODE_ROUNDING_PRECISION,
+            )
+        )
+        await self._send_command(command=c)
+
+    async def get_temperature(self) -> Temperature:
+        """
+        Send a get temperature command to the temp deck.
+
+        Returns: Temperature object
+
+        """
+        c = CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.GET_TEMP
+        )
+        response = await self._send_command(command=c)
+        return utils.parse_temperature_response(
+            temperature_string=response,
+            rounding_val=utils.TEMPDECK_GCODE_ROUNDING_PRECISION,
+        )
+
+    async def get_device_info(self) -> Dict[str, str]:
+        """
+        Queries Temp-Deck for its build version, model, and serial number
+
+        returns: dict
+            Where keys are the strings 'version', 'model', and 'serial',
+            and each value is a string identifier
+
+            {
+                'serial': '1aa11bb22',
+                'model': '1aa11bb22',
+                'version': '1aa11bb22'
+            }
+
+        Example input from Temp-Deck's serial response:
+            "serial:aa11bb22 model:aa11bb22 version:aa11bb22"
+        """
+        device_info = CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.DEVICE_INFO
+        )
+        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:
+        """
+        Send command to enter programming mode.
+
+        Returns: None
+        """
+        c = CommandBuilder(terminator=TEMP_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.PROGRAMMING_MODE
+        )
+        await self._send_command(command=c)
+
+    async def _send_command(self, command: CommandBuilder) -> str:
+        """
+        Send the command
+
+        Args:
+            command: command to send
+
+        Returns:
+            command response
+        """
+        response = await self._connection.send_command(
+            command=command, retries=DEFAULT_COMMAND_RETRIES
+        )
+        return response

opentrons/drivers/temp_deck/simulator.py

@@ -0,0 +1,57 @@
+from typing import Optional, Dict
+
+from opentrons.util.async_helpers import ensure_yield
+from opentrons.drivers.types import Temperature
+from opentrons.drivers.temp_deck.abstract import AbstractTempDeckDriver
+
+TEMP_DECK_MODELS = {
+    "temperatureModuleV1": "temp_deck_v1.1",
+    "temperatureModuleV2": "temp_deck_v20",
+}
+
+
+class SimulatingDriver(AbstractTempDeckDriver):
+    def __init__(
+        self, sim_model: Optional[str] = None, serial_number: Optional[str] = None
+    ):
+        self._temp = Temperature(target=None, current=0)
+        self._port: Optional[str] = None
+        self._model = TEMP_DECK_MODELS[sim_model] if sim_model else "temp_deck_v1.1"
+        self._serial_number = serial_number
+
+    @ensure_yield
+    async def set_temperature(self, celsius: float) -> None:
+        self._temp.target = celsius
+        self._temp.current = self._temp.target
+
+    @ensure_yield
+    async def get_temperature(self) -> Temperature:
+        return self._temp
+
+    @ensure_yield
+    async def deactivate(self) -> None:
+        self._temp = Temperature(target=None, current=23)
+
+    @ensure_yield
+    async def connect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def is_connected(self) -> bool:
+        return True
+
+    @ensure_yield
+    async def disconnect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def enter_programming_mode(self) -> None:
+        pass
+
+    @ensure_yield
+    async def get_device_info(self) -> Dict[str, str]:
+        return {
+            "serial": self._serial_number if self._serial_number else "dummySerialTD",
+            "model": self._model,
+            "version": "dummyVersionTD",
+        }

opentrons/drivers/thermocycler/__init__.py

@@ -0,0 +1,12 @@
+from .driver import ThermocyclerDriver, ThermocyclerDriverV2, ThermocyclerDriverFactory
+from .simulator import SimulatingDriver
+from .abstract import AbstractThermocyclerDriver
+
+
+__all__ = [
+    "ThermocyclerDriver",
+    "ThermocyclerDriverV2",
+    "ThermocyclerDriverFactory",
+    "SimulatingDriver",
+    "AbstractThermocyclerDriver",
+]