opentrons 8.6.0__py3-none-any.whl

opentrons/hardware_control/emulation/settings.py

@@ -0,0 +1,119 @@
+from typing import List
+from opentrons.hardware_control.emulation.types import ModuleType
+from opentrons.hardware_control.emulation.util import TEMPERATURE_ROOM
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class PipetteSettings(BaseModel):
+    model: str = "p20_single_v2.0"
+    id: str = "P20SV202020070101"
+
+
+class SmoothieSettings(BaseModel):
+    left: PipetteSettings = PipetteSettings(
+        model="p20_multi_v2.0", id="P3HMV202020041605"
+    )
+    right: PipetteSettings = PipetteSettings(
+        model="p20_single_v2.0", id="P20SV202020070101"
+    )
+    host: str = "0.0.0.0"
+    port: int = 9996
+
+
+class BaseModuleSettings(BaseModel):
+    serial_number: str
+    model: str
+    version: str
+
+
+class TemperatureModelSettings(BaseModel):
+    degrees_per_tick: float = 2.0
+    starting: float = float(TEMPERATURE_ROOM)
+
+
+class RPMModelSettings(BaseModel):
+    rpm_per_tick: float = 100.0
+    starting: float = 0.0
+
+
+class MagDeckSettings(BaseModuleSettings):
+    pass
+
+
+class TempDeckSettings(BaseModuleSettings):
+    temperature: TemperatureModelSettings
+
+
+class ThermocyclerSettings(BaseModuleSettings):
+    lid_temperature: TemperatureModelSettings
+    plate_temperature: TemperatureModelSettings
+
+
+class HeaterShakerSettings(BaseModuleSettings):
+    temperature: TemperatureModelSettings
+    rpm: RPMModelSettings
+    home_delay_time: int = 0
+
+
+class ProxySettings(BaseModel):
+    """Settings for a proxy."""
+
+    host: str = "0.0.0.0"
+    emulator_port: int
+    driver_port: int
+    use_local_host: bool = True
+
+
+class ModuleServerSettings(BaseModel):
+    """Settings for the module server"""
+
+    host: str = "0.0.0.0"
+    port: int = 8989
+
+
+class Settings(BaseSettings):
+    modules: List[ModuleType] = [
+        ModuleType.Magnetic,
+        ModuleType.Temperature,
+        ModuleType.Thermocycler,
+    ]
+    smoothie: SmoothieSettings = SmoothieSettings()
+    magdeck: MagDeckSettings = MagDeckSettings(
+        serial_number="magnetic_emulator", model="mag_deck_v20", version="2.0.0"
+    )
+    tempdeck: TempDeckSettings = TempDeckSettings(
+        serial_number="temperature_emulator",
+        model="temp_deck_v20",
+        version="v2.0.1",
+        temperature=TemperatureModelSettings(starting=0.0),
+    )
+    thermocycler: ThermocyclerSettings = ThermocyclerSettings(
+        serial_number="thermocycler_emulator",
+        model="v02",
+        version="v1.1.0",
+        lid_temperature=TemperatureModelSettings(),
+        plate_temperature=TemperatureModelSettings(),
+    )
+    heatershaker: HeaterShakerSettings = HeaterShakerSettings(
+        serial_number="heater_shaker_emulator",
+        model="v01",
+        version="v0.0.1",
+        temperature=TemperatureModelSettings(),
+        rpm=RPMModelSettings(),
+        home_delay_time=0,
+    )
+
+    heatershaker_proxy: ProxySettings = ProxySettings(
+        emulator_port=9000, driver_port=9995
+    )
+    thermocycler_proxy: ProxySettings = ProxySettings(
+        emulator_port=9002, driver_port=9997
+    )
+    temperature_proxy: ProxySettings = ProxySettings(
+        emulator_port=9003, driver_port=9998
+    )
+    magdeck_proxy: ProxySettings = ProxySettings(emulator_port=9004, driver_port=9999)
+    model_config = SettingsConfigDict(env_prefix="OT_EMULATOR_")
+
+    module_server: ModuleServerSettings = ModuleServerSettings()

opentrons/hardware_control/emulation/simulations.py

@@ -0,0 +1,133 @@
+from typing import Optional
+
+
+class Simulation:
+    def tick(self) -> None:
+        pass
+
+
+class Temperature(Simulation):
+    """A model with a current and target temperature. The current temperature is
+    always moving towards the target.
+    """
+
+    def __init__(self, per_tick: float, current: float) -> None:
+        """Construct a temperature simulation.
+
+        Args:
+            per_tick: amount to move per tick,
+            current: the starting temperature
+        """
+        self._per_tick = per_tick
+        self._current = current
+        self._target: Optional[float] = None
+
+    def tick(self) -> None:
+        if self._target is None:
+            return
+
+        diff = self._target - self._current
+
+        if abs(diff) < self._per_tick:
+            self._current = self._target
+        elif diff > 0:
+            self._current += self._per_tick
+        else:
+            self._current -= self._per_tick
+
+    def deactivate(self, temperature: float) -> None:
+        """Deactivate and reset to temperature"""
+        self._target = None
+        self._current = temperature
+
+    def set_target(self, target: Optional[float]) -> None:
+        self._target = target
+
+    @property
+    def current(self) -> float:
+        return self._current
+
+    @property
+    def target(self) -> Optional[float]:
+        return self._target
+
+
+class RPM(Simulation):
+    """A model with a current and target rpm. The current rpm is
+    always moving towards the target.
+    """
+
+    def __init__(self, per_tick: float, current: float) -> None:
+        """Construct a rpm simulation.
+
+        Args:
+            per_tick: amount to move per tick,
+            current: the starting rpm
+        """
+        self._per_tick = per_tick
+        self._current = current
+        self._target: Optional[float] = None
+
+    def tick(self) -> None:
+
+        if self._target is None:
+            target = 0.0
+        else:
+            target = self._target
+
+        diff = target - self._current
+
+        if abs(diff) < self._per_tick:
+            self._current = target
+        elif diff > 0:
+            self._current += self._per_tick
+        else:
+            self._current -= self._per_tick
+
+    def deactivate(self, rpm: float) -> None:
+        """Deactivate and reset to rpm"""
+        self._target = None
+        self._current = rpm
+
+    def set_target(self, target: Optional[float]) -> None:
+        self._target = target
+
+    @property
+    def current(self) -> float:
+        return self._current
+
+    @property
+    def target(self) -> Optional[float]:
+        return self._target
+
+
+class TemperatureWithHold(Temperature):
+    """A model with a current temperature, target temperature, and hold time.
+    The current temperature is always moving towards the target.
+
+    When the current temperature is within close enough from target the hold time
+    decrements once per tick.
+    """
+
+    def __init__(self, per_tick: float, current: float) -> None:
+        """Construct a temperature with hold simulation."""
+        super().__init__(per_tick=per_tick, current=current)
+        self._total_hold: Optional[float] = None
+        self._hold: Optional[float] = None
+
+    def tick(self) -> None:
+        super().tick()
+        if self.target == self._current and self._hold is not None:
+            self._hold = max(0, self._hold - 1)
+
+    def set_hold(self, hold: float) -> None:
+        self._total_hold = hold
+        self._hold = hold
+
+    @property
+    def time_remaining(self) -> Optional[float]:
+        return self._hold
+
+    @property
+    def total_hold(self) -> Optional[float]:
+        return self._total_hold

opentrons/hardware_control/emulation/smoothie.py

@@ -0,0 +1,192 @@
+"""An emulation of the Smoothie.
+
+The purpose is to provide a fake backend that responds to the GCODE sent by the
+Opentrons smoothie driver.
+"""
+import logging
+import re
+from typing import Optional, Dict
+
+from opentrons import _find_smoothie_file
+from opentrons.drivers import utils
+from opentrons.drivers.smoothie_drivers.constants import GCODE, HOMED_POSITION
+from opentrons.hardware_control.emulation.parser import Command, Parser
+
+from .abstract_emulator import AbstractEmulator
+from .settings import SmoothieSettings
+
+logger = logging.getLogger(__name__)
+
+
+class SmoothieEmulator(AbstractEmulator):
+    """Smoothie emulator"""
+
+    WRITE_INSTRUMENT_RE = re.compile(r"(?P<mount>[LR])\s*(?P<value>[a-f0-9]+)")
+    INSTRUMENT_AND_MODEL_STRING_LENGTH = 64
+
+    _version_string: str
+    _pos: Dict[str, float]
+    _home_status: Dict[str, bool]
+    _speed: float
+    _pipette_model: Dict[str, str]
+    _pipette_id: Dict[str, str]
+
+    def __init__(self, parser: Parser, settings: SmoothieSettings) -> None:
+        """Constructor.
+
+        Args:
+            parser: GCODE Parser.
+            settings: emulator settings.
+        """
+        self._parser = parser
+        self._settings = settings
+        self._gcode_to_function_mapping = {
+            GCODE.HOMING_STATUS.value: self._get_homing_status,
+            GCODE.CURRENT_POSITION.value: self._get_current_position,
+            GCODE.VERSION.value: self._get_version,
+            GCODE.READ_INSTRUMENT_ID.value: self._get_pipette_id,
+            GCODE.READ_INSTRUMENT_MODEL.value: self._get_pipette_model,
+            GCODE.WRITE_INSTRUMENT_ID.value: self._set_pipette_id,
+            GCODE.WRITE_INSTRUMENT_MODEL.value: self._set_pipette_model,
+            GCODE.MOVE.value: self._move_gantry,
+            GCODE.HOME.value: self._home_gantry,
+        }
+        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
+
+    def reset(self) -> None:
+        _, fw_version = _find_smoothie_file()
+        self._version_string = (
+            f"Build version: {fw_version}, Build date: CURRENT, "
+            f"MCU: NONE, System Clock: NONE"
+        )
+
+        self._pos = {"A": 0.0, "B": 0.0, "C": 0.0, "X": 0.0, "Y": 0.0, "Z": 0.0}
+        self._home_status: Dict[str, bool] = {
+            "X": False,
+            "Y": False,
+            "Z": False,
+            "A": False,
+            "B": False,
+            "C": False,
+        }
+        self._speed = 0.0
+
+        self._pipette_model = {
+            "L": utils.string_to_hex(
+                self._settings.left.model, self.INSTRUMENT_AND_MODEL_STRING_LENGTH
+            ),
+            "R": utils.string_to_hex(
+                self._settings.right.model, self.INSTRUMENT_AND_MODEL_STRING_LENGTH
+            ),
+        }
+
+        self._pipette_id = {
+            "L": utils.string_to_hex(
+                self._settings.left.id, self.INSTRUMENT_AND_MODEL_STRING_LENGTH
+            ),
+            "R": utils.string_to_hex(
+                self._settings.right.id, self.INSTRUMENT_AND_MODEL_STRING_LENGTH
+            ),
+        }
+
+    def get_current_position(self) -> Dict[str, float]:
+        return self._pos
+
+    def _get_homing_status(self, command: Command) -> str:
+        """Get the current homing status of the emulated gantry"""
+        return " ".join(f"{k}:{int(v)}" for k, v in self._home_status.items())
+
+    def _get_current_position(self, command: Command) -> str:
+        """Get the current position of the emulated gantry"""
+        pos_string = " ".join(f"{k}:{v}" for k, v in self._pos.items())
+        return f"{command.gcode}\r\n\r\nok MCS: {pos_string}"
+
+    def _get_version(self, command: Command) -> str:
+        """Get the current firmware version"""
+        return self._version_string
+
+    def _get_pipette_id(self, command: Command) -> Optional[str]:
+        """Get the current id of the specified pipette"""
+        pipette_postion = None
+
+        if "L" in command.params:
+            pipette_postion = f"L:{self._pipette_id['L']}"
+        elif "R" in command.params:
+            pipette_postion = f"R:{self._pipette_id['R']}"
+
+        return pipette_postion
+
+    def _get_pipette_model(self, command: Command) -> Optional[str]:
+        """Get the current model of the specified pipette"""
+        pipette_model = None
+
+        if "L" in command.params:
+            pipette_model = f"L:{self._pipette_model['L']}"
+        elif "R" in command.params:
+            pipette_model = f"R:{self._pipette_model['R']}"
+
+        return pipette_model
+
+    def _set_pipette_id(self, command: Command) -> None:
+        """Sets the id for the pipette"""
+        self._pipette_id.update(self._mount_strings(command))
+
+    def _set_pipette_model(self, command: Command) -> None:
+        """Sets the model for the pipette"""
+        self._pipette_model.update(self._mount_strings(command))
+
+    def _move_gantry(self, command: Command) -> None:
+        """Moves the gantry to the position provided in the command"""
+        for key, value in command.params.items():
+            assert isinstance(value, float), f"invalid value '{value}'"
+            if "F" == key:
+                self._speed = value
+            else:
+                self._pos[key] = value
+
+    def _home_gantry(self, command: Command) -> None:
+        """Returns gantry to home position"""
+        for axis in command.params.keys():
+            self._pos[axis] = HOMED_POSITION[axis]
+            self._home_status[axis] = True
+
+    def _handle(self, command: Command) -> Optional[str]:
+        """Handle a command."""
+        logger.info(f"Got command {command}")
+        func_to_run = self._gcode_to_function_mapping.get(command.gcode)
+        return None if func_to_run is None else func_to_run(command)
+
+    @staticmethod
+    def _mount_strings(command: Command) -> Dict[str, str]:
+        """
+        Parse the body of the command for the mount strings.
+
+        Write instrument id and model use the format:
+            MOUNT VALUE
+        where MOUNT is either L or R and VALUE is a string of ascii codes.
+
+        Args:
+            command: Command
+
+        Returns:
+            A dict of L and/or R to the string value following it.
+        """
+        pars = (
+            i.groupdict()
+            for i in SmoothieEmulator.WRITE_INSTRUMENT_RE.finditer(command.body)
+        )
+        result = {
+            p["mount"]: p["value"]
+            + "0"
+            * (SmoothieEmulator.INSTRUMENT_AND_MODEL_STRING_LENGTH - len(p["value"]))
+            for p in pars
+        }
+
+        assert result, f"missing mount values '{command.body}'"
+        return result

opentrons/hardware_control/emulation/tempdeck.py

@@ -0,0 +1,69 @@
+"""An emulation of the opentrons temperature module.
+
+The purpose is to provide a fake backend that responds to GCODE commands.
+"""
+
+import logging
+from typing import Optional
+
+from opentrons.drivers.temp_deck.driver import GCODE
+from opentrons.hardware_control.emulation import util
+from opentrons.hardware_control.emulation.parser import Parser, Command
+from opentrons.hardware_control.emulation.settings import TempDeckSettings
+
+from .abstract_emulator import AbstractEmulator
+from .simulations import Temperature
+
+
+logger = logging.getLogger(__name__)
+
+
+class TempDeckEmulator(AbstractEmulator):
+    """TempDeck emulator"""
+
+    _temperature: Temperature
+
+    def __init__(self, parser: Parser, settings: TempDeckSettings) -> None:
+        self._settings = settings
+        self._parser = parser
+        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
+
+    def reset(self) -> None:
+        self._temperature = Temperature(
+            per_tick=self._settings.temperature.degrees_per_tick,
+            current=self._settings.temperature.starting,
+        )
+
+    def _handle(self, command: Command) -> Optional[str]:
+        """Handle a command."""
+        logger.info(f"Got command {command}")
+        if command.gcode == GCODE.GET_TEMP:
+            res = (
+                f"T:{util.OptionalValue(self._temperature.target)} "
+                f"C:{self._temperature.current}"
+            )
+            self._temperature.tick()
+            return res
+        elif command.gcode == GCODE.SET_TEMP:
+            temperature = command.params["S"]
+            assert isinstance(
+                temperature, float
+            ), f"invalid temperature '{temperature}'"
+            self._temperature.set_target(temperature)
+        elif command.gcode == GCODE.DISENGAGE:
+            self._temperature.deactivate(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}"
+            )
+        elif command.gcode == GCODE.PROGRAMMING_MODE:
+            pass
+        return None

opentrons/hardware_control/emulation/thermocycler.py

@@ -0,0 +1,128 @@
+"""An emulation of the opentrons thermocycler module.
+
+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.types import ThermocyclerLidStatus
+from opentrons.hardware_control.emulation.parser import Parser, Command
+from opentrons.hardware_control.emulation.settings import ThermocyclerSettings
+
+from .abstract_emulator import AbstractEmulator
+from .simulations import Temperature, TemperatureWithHold
+from . import util
+
+logger = logging.getLogger(__name__)
+
+
+class ThermocyclerEmulator(AbstractEmulator):
+    """Thermocycler emulator"""
+
+    _lid_temperature: Temperature
+    _plate_temperature: TemperatureWithHold
+    lid_status: ThermocyclerLidStatus
+    plate_volume: util.OptionalValue[float]
+    plate_ramp_rate: util.OptionalValue[float]
+
+    def __init__(self, parser: Parser, settings: ThermocyclerSettings) -> None:
+        self._parser = parser
+        self._settings = settings
+        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
+
+    def reset(self) -> None:
+        self._lid_temperature = Temperature(
+            per_tick=self._settings.lid_temperature.degrees_per_tick,
+            current=self._settings.lid_temperature.starting,
+        )
+        self._plate_temperature = TemperatureWithHold(
+            per_tick=self._settings.plate_temperature.degrees_per_tick,
+            current=self._settings.plate_temperature.starting,
+        )
+        self.lid_status = ThermocyclerLidStatus.OPEN
+        self.plate_volume = util.OptionalValue[float]()
+        self.plate_ramp_rate = util.OptionalValue[float]()
+
+    def _handle(self, command: Command) -> Optional[str]:  # noqa: C901
+        """
+        Handle a command.
+
+        TODO: AL 20210218 create dispatch map and remove 'noqa(C901)'
+        """
+        logger.info(f"Got command {command}")
+        if command.gcode == GCODE.OPEN_LID:
+            self.lid_status = ThermocyclerLidStatus.OPEN
+        elif command.gcode == GCODE.CLOSE_LID:
+            self.lid_status = ThermocyclerLidStatus.CLOSED
+        elif command.gcode == GCODE.GET_LID_STATUS:
+            return f"Lid:{self.lid_status}"
+        elif command.gcode == GCODE.SET_LID_TEMP:
+            temperature = command.params["S"]
+            assert isinstance(
+                temperature, float
+            ), f"invalid temperature '{temperature}'"
+            self._lid_temperature.set_target(temperature)
+        elif command.gcode == GCODE.GET_LID_TEMP:
+            res = (
+                f"T:{util.OptionalValue(self._lid_temperature.target)} "
+                f"C:{self._lid_temperature.current} "
+                f"H:none Total_H:none"
+            )
+            self._lid_temperature.tick()
+            return res
+        elif command.gcode == GCODE.EDIT_PID_PARAMS:
+            pass
+        elif command.gcode == GCODE.SET_PLATE_TEMP:
+            for prefix, value in command.params.items():
+                assert isinstance(value, float), f"invalid value '{value}'"
+                if prefix == "S":
+                    self._plate_temperature.set_target(value)
+                elif prefix == "V":
+                    self.plate_volume.val = value
+                elif prefix == "H":
+                    self._plate_temperature.set_hold(value)
+        elif command.gcode == GCODE.GET_PLATE_TEMP:
+            plate_target = util.OptionalValue(self._plate_temperature.target)
+            plate_current = self._plate_temperature.current
+            plate_time_remaining = util.OptionalValue(
+                self._plate_temperature.time_remaining
+            )
+            plate_total_hold_time = util.OptionalValue(
+                self._plate_temperature.total_hold
+            )
+
+            res = (
+                f"T:{plate_target} "
+                f"C:{plate_current} "
+                f"H:{plate_time_remaining} "
+                f"Total_H:{plate_total_hold_time} "
+            )
+            self._plate_temperature.tick()
+            return res
+        elif command.gcode == GCODE.SET_RAMP_RATE:
+            self.plate_ramp_rate.val = command.params["S"]
+        elif command.gcode == GCODE.DEACTIVATE_ALL:
+            self._plate_temperature.deactivate(temperature=util.TEMPERATURE_ROOM)
+            self._lid_temperature.deactivate(temperature=util.TEMPERATURE_ROOM)
+        elif command.gcode == GCODE.DEACTIVATE_LID:
+            self._lid_temperature.deactivate(temperature=util.TEMPERATURE_ROOM)
+        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
+
+    @staticmethod
+    def get_terminator() -> bytes:
+        return b"\r\n"

opentrons/hardware_control/emulation/types.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ModuleType(str, Enum):
+    """Module type enumeration."""
+
+    Magnetic = "magdeck"
+    Temperature = "tempdeck"
+    Thermocycler = "thermocycler"
+    Heatershaker = "heatershaker"

opentrons/hardware_control/emulation/util.py

@@ -0,0 +1,38 @@
+from typing import Optional, Generic, TypeVar
+
+TEMPERATURE_ROOM = 23
+
+
+ValueType = TypeVar("ValueType")
+
+
+class OptionalValue(Generic[ValueType]):
+    """
+    A class that serializes optional values.
+
+    Modules represent a null value as 'none'. For example this response from
+    the thermocycler means the hold time is not set:
+        H:none T:1.23
+    """
+
+    _value: Optional[ValueType]
+
+    def __init__(self, value: Optional[ValueType] = None):
+        self._value = value
+
+    @property
+    def val(self) -> Optional[ValueType]:
+        return self._value
+
+    @val.setter
+    def val(self, value: Optional[ValueType]) -> None:
+        self._value = value
+
+    def __repr__(self) -> str:
+        return "none" if self._value is None else str(self._value)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, OptionalValue):
+            return False
+
+        return other.val == self.val