opentrons 8.6.0a1__py3-none-any.whl

opentrons/drivers/heater_shaker/simulator.py

@@ -0,0 +1,94 @@
+from typing import Dict, Optional
+from opentrons.util.async_helpers import ensure_yield
+from opentrons.drivers.heater_shaker.abstract import AbstractHeaterShakerDriver
+from opentrons.drivers.types import Temperature, RPM, HeaterShakerLabwareLatchStatus
+
+
+class SimulatingDriver(AbstractHeaterShakerDriver):
+    DEFAULT_TEMP = 23
+
+    def __init__(self, serial_number: Optional[str] = None) -> None:
+        self._labware_latch_state = HeaterShakerLabwareLatchStatus.IDLE_UNKNOWN
+        self._current_temperature = self.DEFAULT_TEMP
+        self._temperature = Temperature(current=self.DEFAULT_TEMP, target=None)
+        self._rpm = RPM(current=0, target=None)
+        self._homing_status = True
+        self._serial_number = serial_number
+
+    @ensure_yield
+    async def connect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def disconnect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def is_connected(self) -> bool:
+        return True
+
+    @ensure_yield
+    async def open_labware_latch(self) -> None:
+        self._labware_latch_state = HeaterShakerLabwareLatchStatus.IDLE_OPEN
+
+    @ensure_yield
+    async def close_labware_latch(self) -> None:
+        self._labware_latch_state = HeaterShakerLabwareLatchStatus.IDLE_CLOSED
+
+    @ensure_yield
+    async def get_labware_latch_status(self) -> HeaterShakerLabwareLatchStatus:
+        return self._labware_latch_state
+
+    @ensure_yield
+    async def set_temperature(self, temperature: float) -> None:
+        self._temperature.current = temperature
+        self._temperature.target = temperature if temperature != 0.0 else None
+
+    @ensure_yield
+    async def get_temperature(self) -> Temperature:
+        return self._temperature
+
+    @ensure_yield
+    async def set_rpm(self, rpm: int) -> None:
+        self._rpm.target = rpm if rpm != 0 else None
+        self._rpm.current = rpm
+        self._homing_status = False
+
+    @ensure_yield
+    async def get_rpm(self) -> RPM:
+        return self._rpm
+
+    @ensure_yield
+    async def home(self) -> None:
+        self._rpm.target = None
+        self._rpm.current = 0
+        self._homing_status = True
+
+    @ensure_yield
+    async def deactivate_heater(self) -> None:
+        self._temperature.target = None
+        self._temperature.current = 23
+
+    @ensure_yield
+    async def deactivate_shaker(self) -> None:
+        self._rpm.target = 0
+        self._rpm.current = 0
+
+    @ensure_yield
+    async def deactivate(self) -> None:
+        self._temperature.target = None
+        self._temperature.current = 23
+        self._rpm.target = 0
+        self._rpm.current = 0
+
+    @ensure_yield
+    async def get_device_info(self) -> Dict[str, str]:
+        return {
+            "serial": self._serial_number if self._serial_number else "dummySerialHS",
+            "model": "dummyModelHS",
+            "version": "dummyVersionHS",
+        }
+
+    @ensure_yield
+    async def enter_programming_mode(self) -> None:
+        pass

opentrons/drivers/mag_deck/__init__.py

@@ -0,0 +1,6 @@
+from .abstract import AbstractMagDeckDriver
+from .simulator import SimulatingDriver
+from .driver import MagDeckDriver
+
+
+__all__ = ["AbstractMagDeckDriver", "SimulatingDriver", "MagDeckDriver"]

opentrons/drivers/mag_deck/abstract.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from typing import Dict
+
+
+class AbstractMagDeckDriver(ABC):
+    @abstractmethod
+    async def connect(self) -> None:
+        ...
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        ...
+
+    @abstractmethod
+    async def is_connected(self) -> bool:
+        pass
+
+    @abstractmethod
+    async def home(self) -> None:
+        ...
+
+    @abstractmethod
+    async def probe_plate(self) -> None:
+        ...
+
+    @abstractmethod
+    async def get_plate_height(self) -> float:
+        ...
+
+    @abstractmethod
+    async def get_mag_position(self) -> float:
+        ...
+
+    @abstractmethod
+    async def move(self, position_mm: float) -> None:
+        ...
+
+    @abstractmethod
+    async def get_device_info(self) -> Dict[str, str]:
+        ...
+
+    @abstractmethod
+    async def enter_programming_mode(self) -> None:
+        ...

opentrons/drivers/mag_deck/driver.py

@@ -0,0 +1,208 @@
+"""
+- This driver is responsible for providing an interface for the mag deck
+- The driver is the only system component that knows about the mag-deck's
+  GCODES or how the mag-deck communicates
+
+- The driver is NOT responsible for interpreting deck 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.command_builder import CommandBuilder
+from opentrons.drivers.asyncio.communication import SerialConnection
+from .abstract import AbstractMagDeckDriver
+
+log = logging.getLogger(__name__)
+
+DEFAULT_MAG_DECK_TIMEOUT = 10  # Quite large to account for probe time
+
+DEFAULT_COMMAND_RETRIES = 3
+
+
+class GCODE(str, Enum):
+    HOME = "G28.2"
+    PROBE_PLATE = "G38.2"
+    GET_PLATE_HEIGHT = "M836"
+    GET_CURRENT_POSITION = "M114.2"
+    MOVE = "G0"
+    DEVICE_INFO = "M115"
+    PROGRAMMING_MODE = "dfu"
+
+
+MAG_DECK_BAUDRATE = 115200
+
+MAG_DECK_COMMAND_TERMINATOR = "\r\n\r\n"
+MAG_DECK_ACK = "ok\r\nok\r\n"
+
+
+# Number of digits after the decimal point for millimeter values
+# being sent to/from magnetic module
+GCODE_ROUNDING_PRECISION = 3
+
+
+class MagDeckError(Exception):
+    pass
+
+
+class MagDeckDriver(AbstractMagDeckDriver):
+    @classmethod
+    async def create(
+        cls, port: str, loop: Optional[asyncio.AbstractEventLoop] = None
+    ) -> MagDeckDriver:
+        """
+        Create a mag deck driver.
+
+        Args:
+            port: port or url of magdeck
+            loop: optional event loop
+
+        Returns: driver
+        """
+        connection = await SerialConnection.create(
+            port=port,
+            baud_rate=MAG_DECK_BAUDRATE,
+            timeout=DEFAULT_MAG_DECK_TIMEOUT,
+            ack=MAG_DECK_ACK,
+            loop=loop,
+            reset_buffer_before_write=False,
+        )
+        return cls(connection=connection)
+
+    def __init__(self, connection: SerialConnection):
+        """
+        Constructor
+
+        Args:
+            connection: connection to magdeck.
+        """
+        self._connection = connection
+
+    async def connect(self) -> None:
+        """Connect to device"""
+        await self._connection.open()
+
+    async def disconnect(self) -> None:
+        """Disconnect from device"""
+        await self._connection.close()
+
+    async def is_connected(self) -> bool:
+        """Check if connected."""
+        return await self._connection.is_open()
+
+    async def home(self) -> None:
+        """Homes the magnet"""
+        c = CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.HOME
+        )
+        await self._send_command(c)
+
+    async def probe_plate(self) -> None:
+        """
+        Probes for the deck plate and calculates the plate distance
+        from home.
+        To be used for calibrating MagDeck
+        """
+        c = CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.PROBE_PLATE
+        )
+        await self._send_command(c)
+
+    async def get_plate_height(self) -> float:
+        """
+        Default plate_height for the device is 30;
+        calculated as MAX_TRAVEL_DISTANCE(45mm) - 15mm
+        """
+        c = CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.GET_PLATE_HEIGHT
+        )
+        response = await self._send_command(c)
+        data = utils.parse_key_values(response)
+        return utils.parse_number(str(data.get("height")), GCODE_ROUNDING_PRECISION)
+
+    async def get_mag_position(self) -> float:
+        """
+        Default mag_position for the device is 0.0
+        i.e. it boots with the current position as 0.0
+        """
+        c = CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.GET_CURRENT_POSITION
+        )
+
+        response = await self._send_command(c)
+        data = utils.parse_key_values(response)
+        return utils.parse_number(str(data.get("Z")), GCODE_ROUNDING_PRECISION)
+
+    async def move(self, position: float) -> None:
+        """
+        Move the magnets along Z axis where the home position is 0.0;
+        position-> a point along Z. Does not self-check if the position
+        is outside of the deck's linear range
+
+        The units of position depend on the module model.
+        For GEN1, it's half millimeters ("short millimeters").
+        For GEN2, it's millimeters.
+        """
+        c = (
+            CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR)
+            .add_gcode(gcode=GCODE.MOVE)
+            .add_float(prefix="Z", value=position, precision=GCODE_ROUNDING_PRECISION)
+        )
+        await self._send_command(c)
+
+    async def get_device_info(self) -> Dict[str, str]:
+        """
+        Queries Mag-Deck for it's 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 Mag-Deck's serial response:
+            "serial:aa11bb22 model:aa11bb22 version:aa11bb22"
+        """
+        c = CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.DEVICE_INFO
+        )
+        response = await self._send_command(c)
+        return utils.parse_device_information(device_info_string=response)
+
+    async def enter_programming_mode(self) -> None:
+        """
+        Enters and stays in DFU mode for 8 seconds.
+        The module resets upon exiting the mode
+        which causes the robot to lose serial connection to it.
+        The connection can be restored by performing a .disconnect()
+        followed by a .connect() to the same symlink node
+        """
+        c = CommandBuilder(terminator=MAG_DECK_COMMAND_TERMINATOR).add_gcode(
+            gcode=GCODE.PROGRAMMING_MODE
+        )
+        await self._send_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/mag_deck/simulator.py

@@ -0,0 +1,63 @@
+from typing import Dict, Optional
+
+from .abstract import AbstractMagDeckDriver
+from opentrons.util.async_helpers import ensure_yield
+
+
+MAG_DECK_MODELS = {
+    "magneticModuleV1": "mag_deck_v1.1",
+    "magneticModuleV2": "mag_deck_v20",
+}
+
+
+class SimulatingDriver(AbstractMagDeckDriver):
+    def __init__(
+        self, sim_model: Optional[str] = None, serial_number: Optional[str] = None
+    ) -> None:
+        self._height = 0.0
+        self._model = MAG_DECK_MODELS[sim_model] if sim_model else "mag_deck_v1.1"
+        self._serial_number = serial_number
+
+    @ensure_yield
+    async def probe_plate(self) -> None:
+        pass
+
+    @ensure_yield
+    async def home(self) -> None:
+        pass
+
+    @ensure_yield
+    async def move(self, location: float) -> None:
+        self._height = location
+
+    @ensure_yield
+    async def get_device_info(self) -> Dict[str, str]:
+        return {
+            "serial": self._serial_number if self._serial_number else "dummySerialMD",
+            "model": self._model,
+            "version": "dummyVersionMD",
+        }
+
+    @ensure_yield
+    async def connect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def disconnect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def enter_programming_mode(self) -> None:
+        pass
+
+    @ensure_yield
+    async def is_connected(self) -> bool:
+        return True
+
+    @ensure_yield
+    async def get_plate_height(self) -> float:
+        return self._height
+
+    @ensure_yield
+    async def get_mag_position(self) -> float:
+        return self._height

opentrons/drivers/rpi_drivers/__init__.py

@@ -0,0 +1,33 @@
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .dev_types import GPIODriverLike
+
+MODULE_LOG = logging.getLogger(__name__)
+
+
+class RevisionPinsError(Exception):
+    pass
+
+
+def build_gpio_chardev(chip_name: str) -> "GPIODriverLike":
+    try:
+        from .gpio import GPIOCharDev
+
+        return GPIOCharDev(chip_name)
+    except (ImportError, OSError):
+        MODULE_LOG.warning(
+            "Failed to initialize character device, will not "
+            "be able to control gpios (lights, button, smoothie"
+            "kill, smoothie reset). Only one connection can be"
+            " made to the gpios at a time. "
+            "If you need to control gpios, first stop the robot "
+            "server with systemctl stop opentrons-robot-server. "
+            "Until you restart the server with systemctl start "
+            "opentrons-robot-server, you will be unable to "
+            "control the robot using the Opentrons app."
+        )
+        from .gpio_simulator import SimulatingGPIOCharDev
+
+        return SimulatingGPIOCharDev(chip_name)

opentrons/drivers/rpi_drivers/dev_types.py

@@ -0,0 +1,94 @@
+import asyncio
+from typing import Callable, Dict, Tuple
+from typing_extensions import Protocol
+from opentrons.hardware_control.types import BoardRevision, DoorState
+from .types import GPIOPin
+
+
+class GPIODriverLike(Protocol):
+    """Interface for the GPIO drivers"""
+
+    def __init__(self, chip_name: str) -> None:
+        ...
+
+    @property
+    def chip(self) -> str:
+        ...
+
+    @property
+    def lines(self) -> Dict[str, int]:
+        ...
+
+    @property
+    def board_rev(self) -> BoardRevision:
+        ...
+
+    @board_rev.setter
+    def board_rev(self, boardrev: BoardRevision) -> None:
+        ...
+
+    async def setup(self) -> None:
+        ...
+
+    def config_by_board_rev(self) -> None:
+        ...
+
+    def set_high(self, output_pin: GPIOPin) -> None:
+        ...
+
+    def set_low(self, output_pin: GPIOPin) -> None:
+        ...
+
+    def set_button_light(
+        self, red: bool = False, green: bool = False, blue: bool = False
+    ) -> None:
+        ...
+
+    def set_rail_lights(self, on: bool = True) -> None:
+        ...
+
+    def set_reset_pin(self, on: bool = True) -> None:
+        ...
+
+    def set_isp_pin(self, on: bool = True) -> None:
+        ...
+
+    def set_halt_pin(self, on: bool = True) -> None:
+        ...
+
+    def get_button_light(self) -> Tuple[bool, bool, bool]:
+        ...
+
+    def get_rail_lights(self) -> bool:
+        ...
+
+    def read_button(self) -> bool:
+        ...
+
+    def read_window_switches(self) -> bool:
+        ...
+
+    def read_top_window_switch(self) -> bool:
+        ...
+
+    def read_front_door_switch(self) -> bool:
+        ...
+
+    def read_revision_bits(self) -> Tuple[bool, bool]:
+        ...
+
+    def get_door_state(self) -> DoorState:
+        ...
+
+    def start_door_switch_watcher(
+        self,
+        loop: asyncio.AbstractEventLoop,
+        update_door_state: Callable[[DoorState], None],
+    ) -> None:
+        ...
+
+    def release_line(self, pin: GPIOPin) -> None:
+        ...
+
+    def stop_door_switch_watcher(self, loop: asyncio.AbstractEventLoop) -> None:
+        ...