opentrons 8.6.0__py3-none-any.whl

opentrons/drivers/rpi_drivers/types.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+import enum
+import re
+from itertools import groupby
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+from opentrons.hardware_control.types import BoardRevision
+
+
+class PinDir(enum.Enum):
+    rev_input = enum.auto()
+    input = enum.auto()
+    output = enum.auto()
+
+
+class PortGroup:
+    MAIN = "main"
+    LEFT = "left"
+    RIGHT = "right"
+    FRONT = "front"
+    UNKNOWN = "unknown"
+
+
+REV_OG_USB_PORTS = {"3": 1, "5": 2}
+REV_A_USB_HUB = 3
+FLEX_B2_USB_PORT_GROUP_LEFT = 4
+FLEX_B2_USB_PORT_GROUP_RIGHT = 3
+FLEX_B2_USB_PORT_GROUP_FRONT = 7
+FLEX_B2_USB_PORTS = {"4": 1, "3": 2, "2": 3, "1": 4}
+
+BUS_PATH = "/sys/bus/usb/devices/usb1/"
+
+# Example usb path might look like:
+# '/sys/bus/usb/devices/usb1/1-1/1-1.3/1-1.3:1.0/tty/ttyACM1/dev'.
+# Example hid device path might look like:
+# '/sys/bus/usb/devices/usb1/1-1/1-1.3/1-1.3:1.0/0003:16D0:1199.0002/hidraw/hidraw0/dev'
+# There is only 1 bus that supports USB on the raspberry pi.
+USB_PORT_INFO = re.compile(
+    r"""
+    (?P<port_path>(\d[\d]*-\d[\d\.]*[/]?)+):
+    (?P<device_path>
+        \d.\d/
+        (tty/tty(\w{4})/dev | [\w:\.]+?/hidraw/hidraw\d/dev)
+    )
+    """,
+    re.VERBOSE,
+)
+
+HUB_PATTERN = re.compile(r"(\d-[\d.]+\d?)[\/:]")
+
+
+@dataclass(frozen=True)
+class USBPort:
+    name: str
+    port_number: int
+    port_group: str = PortGroup.UNKNOWN
+    hub: bool = False
+    hub_port: Optional[int] = None
+    device_path: str = ""
+
+    @classmethod
+    def build(
+        cls, full_path: str, board_revision: BoardRevision
+    ) -> Optional["USBPort"]:
+        """
+        Build a USBPort dataclass.
+
+        An example port path:
+        `1-1.3/1-1.3:1.0/tty/ttyACM1/dev`
+
+        Args:
+            port_path: Full path of a usb device
+            board_revision: Board revision
+
+        Returns:
+            Tuple of the port number, port group, hub, hub port, device path, and name
+        """
+        match = USB_PORT_INFO.search(full_path)
+        if not match:
+            return None
+
+        port_path = match.group("port_path")
+        device_path = match.group("device_path")
+        port_nodes = cls.get_unique_nodes(port_path)
+        hub, port, hub_port, name = cls.find_hub(port_nodes, board_revision)
+        hub, port_group, port, hub_port = cls.map_to_revision(
+            board_revision,
+            (
+                hub,
+                port,
+                hub_port,
+            ),
+        )
+        return cls(
+            name=name,
+            port_number=port,
+            port_group=port_group,
+            hub=hub,
+            hub_port=hub_port,
+            device_path=device_path,
+        )
+
+    @staticmethod
+    def find_hub(
+        port_nodes: List[str],
+        board_revision: BoardRevision,
+    ) -> Tuple[Optional[int], int, Optional[int], str]:
+        """
+        Find the hub, port, and hub_port data for a USB port from
+        the port nodes.
+
+        The last item of the port nodes list is parsed by splitting
+        the item at each period. It is parsed as follows:
+        'bus.hub.port.hub_port'. The USB bus data is unused. The
+        hub_port data is only populated if a USB hub is connected
+        to that port. The Flex FRONT USB port is parsed as:
+        'bus.hub.hub_port'.
+
+        :param port_nodes: A list of unique port id(s)
+        :returns: Tuple of the hub, port number, hub_port and name
+        """
+        if len(port_nodes) == 1 and "." not in port_nodes[0]:
+            # if no hub is attached, such as on a dev kit, the port
+            # nodes available will be 1-1
+            port = int(port_nodes[0].split("-")[1])
+            hub = None
+            hub_port = None
+            name = port_nodes[0]
+        else:
+            port_nodes = [node for node in port_nodes if "." in node]
+            if len(port_nodes) > 2:
+                port_info = port_nodes[2].split(".")
+                hub = int(port_info[1])
+                port = int(port_info[2])
+                hub_port = int(port_info[3])
+                name = port_nodes[2]
+            elif len(port_nodes) > 1:
+                if board_revision == BoardRevision.OG:
+                    port_info = port_nodes[1].split(".")
+                    hub = int(port_info[1])
+                    port = int(port_info[1])
+                    hub_port = int(port_info[2])
+                    name = port_nodes[1]
+                else:
+                    port_info = port_nodes[1].split(".")
+                    hub = int(port_info[1])
+                    name = port_nodes[1]
+                    if (board_revision == BoardRevision.FLEX_B2) and (
+                        hub == FLEX_B2_USB_PORT_GROUP_FRONT
+                    ):
+                        port = 9
+                        hub_port = int(port_info[2])
+                    else:
+                        port = int(port_info[2])
+                        hub_port = None
+            else:
+                if board_revision == BoardRevision.FLEX_B2:
+                    port_info = port_nodes[0].split(".")
+                    hub = int(port_info[1])
+                    port = 9
+                    hub_port = None
+                    name = port_nodes[0]
+                else:
+                    port = int(port_nodes[0].split(".")[1])
+                    hub = None
+                    hub_port = None
+                    name = port_nodes[0]
+        return hub, port, hub_port, name
+
+    @staticmethod
+    def get_unique_nodes(full_name: str) -> List[str]:
+        """
+        Get unique port nodes for a USB port from the USB port path.
+
+        For a Flex or OT-2_R with a USB hub connected to a port,
+        the USB port path will look like:
+        `1-1.3/1-1.3.2/1-1.3.2.4/1-1.3.2.4`. This will become the
+        following 3 port nodes: ['1-1.3', '1-1.3.2', '1-1.3.2.4'].
+        The Flex FRONT USB port with a hub connected will look like:
+        `1-1.7/1-1.7.4/1-1.7.4` and become ['1-1.7', '1-1.7.4'].
+
+        For a Flex or OT-2_R without a USB hub connected to a port,
+        the USB port path will look like: `1-1.3/1-1.3.4/1-1.3.4`.
+        This will become the follwing 2 port nodes: ['1-1.3', '1-1.3.4'].
+        The Flex FRONT USB port without a hub connected will look like:
+        `1-1.7/1-1.7` and become ['1-1.7'].
+
+        For a OT-2_OG with a USB hub connected to a port, the USB
+        port path will look like: `1-1.3/1-1.3/1-1.3.3/1-1.3.3`. This will
+        become the following 2 port nodes: ['1-1.3', '1-1.3.3'].
+
+        For a OT-2_OG without a USB hub connected to a port, the USB
+        port path will look like: `1-1.3/1-1.3`. This will become the
+        following 1 port node: ['1-1.3'].
+
+        We only need one unique id here, so we will filter out duplicates.
+
+        :param full_name: Full path of the physical USB Path
+        :returns: List of separated USB port paths
+        """
+        all_match = HUB_PATTERN.findall(full_name)
+        match_set = []
+        for match in all_match:
+            if match not in match_set:
+                match_set.append(match)
+        return match_set
+
+    @staticmethod
+    def map_to_revision(
+        board_revision: BoardRevision,
+        port_info: Tuple[Optional[int], int, Optional[int]],
+    ) -> Tuple[bool, str, int, Optional[int]]:
+        """
+        Synthesize the hub, port_group, and hub_port data for a USB port
+        from the hub and hub_port data.
+
+        If a USB hub is connected to a port, the hub data field is True
+        and the hub_port data field is populated. Otherwise, the hub
+        data field is False and the hub_port data field is None.
+
+        For the OT-2, there is only one bank of USB ports, so the
+        port_group is always MAIN. For the Flex, there are LEFT, RIGHT,
+        and FRONT USB port banks, which map to specific hub values.
+
+        For the Flex, the RIGHT port values are increased by 4 to match
+        the physical hardware labeling (USB5 - USB8).
+
+        :param port_info: Tuple of the hub, port number, and hub port
+        :returns: Tuple of the hub, port group, port number, and hub port
+        """
+        hub, port, hub_port = port_info
+        if board_revision == BoardRevision.OG:
+            if hub:
+                return (
+                    True,
+                    PortGroup.MAIN,
+                    REV_OG_USB_PORTS.get(str(port), port),
+                    hub_port,
+                )
+            else:
+                return (
+                    False,
+                    PortGroup.MAIN,
+                    REV_OG_USB_PORTS.get(str(port), port),
+                    None,
+                )
+        elif board_revision == BoardRevision.FLEX_B2:
+            if hub == FLEX_B2_USB_PORT_GROUP_LEFT:
+                port_group = PortGroup.LEFT
+                port = FLEX_B2_USB_PORTS.get(str(port), port)
+            elif hub == FLEX_B2_USB_PORT_GROUP_RIGHT:
+                port_group = PortGroup.RIGHT
+                port = FLEX_B2_USB_PORTS.get(str(port), port)
+                port = port + 4
+            elif hub == FLEX_B2_USB_PORT_GROUP_FRONT:
+                port_group = PortGroup.FRONT
+            else:
+                port_group = PortGroup.UNKNOWN
+            if hub_port:
+                return True, port_group, port, hub_port
+            else:
+                return False, port_group, port, None
+        else:  # any variant of OT2-Refresh
+            if hub_port:
+                return True, PortGroup.MAIN, port, hub_port
+            else:
+                return False, PortGroup.MAIN, port, None
+
+    def __hash__(self) -> int:
+        """
+        Hash function.
+
+        To have a unique set of nodes, they must
+        all have a unique hash. Lists are not
+        hashable which is why we need to unpack
+        the list here.
+        """
+        return hash(self.name)
+
+
+class GPIOPin:
+    @classmethod
+    def build(cls, name: str, in_out: PinDir, pin: int) -> GPIOPin:
+        # use this method if the pin number is the same
+        # across all board revisions
+        return cls(name, in_out, rev_og=pin, rev_a=pin, rev_b=pin, rev_c=pin)
+
+    @classmethod
+    def build_with_rev(
+        cls, name: str, in_out: PinDir, **kwargs: Optional[int]
+    ) -> GPIOPin:
+        return cls(name, in_out, **kwargs)
+
+    def __init__(
+        self,
+        name: str,
+        in_out: PinDir,
+        rev_og: Optional[int] = None,
+        rev_a: Optional[int] = None,
+        rev_b: Optional[int] = None,
+        rev_c: Optional[int] = None,
+    ):
+        self.name = name
+        self.in_out = in_out
+        self.rev_og = rev_og
+        self.rev_a = rev_a
+        self.rev_b = rev_b
+        self.rev_c = rev_c
+
+    def by_board_rev(self, board_rev: BoardRevision) -> Optional[int]:
+        ref = {
+            BoardRevision.OG: self.rev_og,
+            BoardRevision.A: self.rev_a,
+            BoardRevision.B: self.rev_b,
+            BoardRevision.C: self.rev_c,
+            BoardRevision.UNKNOWN: self.rev_og,
+        }
+        return ref[board_rev]
+
+
+class GPIOGroup:
+    def __init__(self, pins: List[GPIOPin]):
+        self.pins = pins
+
+    def __getattr__(self, item: str) -> GPIOPin:
+        res = next(filter(lambda x: x.name is item, self.pins), None)
+        assert res, f"Failed to find GPIOPin named: {item}"
+        return res
+
+    def by_type(self, pin_dir: PinDir) -> GPIOGroup:
+        return GPIOGroup(list(filter(lambda x: x.in_out is pin_dir, self.pins)))
+
+    def by_names(self, names: List[str]) -> GPIOGroup:
+        return GPIOGroup(list(filter(lambda x: x.name in names, self.pins)))
+
+    def group_by_pins(self, board_rev: BoardRevision) -> List[List[GPIOPin]]:
+        c = groupby(self.pins, key=lambda x: x.by_board_rev(board_rev))
+        l: List[List[GPIOPin]] = []
+        for k, v in c:
+            l.append(list(v))
+        return l
+
+
+gpio_group = GPIOGroup(
+    [
+        # revision pins (input)
+        GPIOPin.build("rev_0", PinDir.rev_input, 17),
+        GPIOPin.build("rev_1", PinDir.rev_input, 27),
+        # output pins
+        GPIOPin.build("frame_leds", PinDir.output, 6),
+        GPIOPin.build("blue_button", PinDir.output, 13),
+        GPIOPin.build("halt", PinDir.output, 18),
+        GPIOPin.build("green_button", PinDir.output, 19),
+        GPIOPin.build("audio_enable", PinDir.output, 21),
+        GPIOPin.build("isp", PinDir.output, 23),
+        GPIOPin.build("reset", PinDir.output, 24),
+        GPIOPin.build("red_button", PinDir.output, 26),
+        # input pins
+        GPIOPin.build("button_input", PinDir.input, 5),
+        GPIOPin.build_with_rev("door_sw_filt", PinDir.input, rev_og=20, rev_a=12),
+        GPIOPin.build_with_rev("window_sw_filt", PinDir.input, rev_og=20, rev_a=16),
+        GPIOPin.build("window_door_sw", PinDir.input, 20),
+    ]
+)

opentrons/drivers/rpi_drivers/usb.py

@@ -0,0 +1,102 @@
+"""
+USB Driver.
+
+A class to convert info from the usb bus into a
+more readable format.
+"""
+
+import subprocess
+import os
+from typing import List, Union
+
+from opentrons.hardware_control.modules.types import (
+    ModuleAtPort,
+    SimulatingModuleAtPort,
+)
+from opentrons.hardware_control.types import BoardRevision
+
+from .interfaces import USBDriverInterface
+from .types import BUS_PATH, USBPort
+
+
+class USBBus(USBDriverInterface):
+    def __init__(self, board_revision: BoardRevision):
+        self._board_revision = board_revision
+
+    @staticmethod
+    def _read_bus() -> List[str]:
+        """
+        Read the USB Bus information.
+
+        Use the sys bus path to find all of the USBs with
+        active devices connected to them.
+        """
+        read = [""]
+        try:
+            read = (
+                subprocess.check_output(["find", BUS_PATH, "-name", "dev"])
+                .decode()
+                .splitlines()
+            )
+        except Exception:
+            pass
+        return read
+
+    @staticmethod
+    def _read_symlink(virtual_port: str) -> str:
+        """ """
+        symlink = ""
+        try:
+            symlink = os.readlink(virtual_port)
+        except OSError:
+            pass
+        return symlink
+
+    def _read_usb_bus(self) -> List[USBPort]:
+        """
+        Read usb bus
+
+        Take the value returned from the USB bus and match
+        the paths to the expected port paths for modules.
+        :returns: A list of matching ports as dataclasses
+        """
+        active_ports = self._read_bus()
+        port_matches = []
+        for port in active_ports:
+            usb_port = USBPort.build(port.strip("/"), self._board_revision)
+            if usb_port:
+                port_matches.append(usb_port)
+        return port_matches
+
+    def match_virtual_ports(
+        self,
+        virtual_ports: Union[List[ModuleAtPort], List[SimulatingModuleAtPort]],
+    ) -> Union[List[ModuleAtPort], List[SimulatingModuleAtPort]]:
+        """
+        Match Virtual Ports
+
+        Given a list of virtual module ports, look up the
+        symlink to find the device path and link that to
+        the physical usb port information.
+        The virtual port path looks something like:
+        dev/ot_module_[MODULE NAME]
+        :param virtual_ports: A list of ModuleAtPort or SimulatingModuleAtPort objects
+        that hold the name and virtual port of each module
+        connected to the robot.
+
+        :returns: The updated list of ModuleAtPort
+        dataclasses with the physical usb port
+        information updated.
+        """
+        actual_ports = self._read_usb_bus()
+        sorted_virtual_ports = []
+
+        for p in actual_ports:
+            for vp in virtual_ports:
+                serial_port = self._read_symlink(vp.port)
+                if serial_port in p.device_path:
+                    vp.usb_port = p
+                    sorted_virtual_ports.append(vp)
+                    break
+
+        return sorted_virtual_ports or virtual_ports

opentrons/drivers/rpi_drivers/usb_simulator.py

@@ -0,0 +1,22 @@
+"""
+USB Simulating Driver.
+
+A class to convert info from the usb bus into a
+more readable format.
+"""
+from typing import List, Union
+
+from opentrons.hardware_control.modules.types import (
+    ModuleAtPort,
+    SimulatingModuleAtPort,
+)
+
+from .interfaces import USBDriverInterface
+
+
+class USBBusSimulator(USBDriverInterface):
+    def match_virtual_ports(
+        self,
+        virtual_port: Union[List[ModuleAtPort], List[SimulatingModuleAtPort]],
+    ) -> Union[List[ModuleAtPort], List[SimulatingModuleAtPort]]:
+        return virtual_port

opentrons/drivers/serial_communication.py

@@ -0,0 +1,151 @@
+from typing import List, Optional, Iterator
+
+import serial  # type: ignore[import-untyped]
+from serial import Serial
+from serial.tools import list_ports  # type: ignore[import-untyped]
+import contextlib
+import logging
+
+from serial.tools.list_ports_common import ListPortInfo  # type: ignore[import-untyped]
+
+log = logging.getLogger(__name__)
+
+RECOVERY_TIMEOUT = 10
+DEFAULT_SERIAL_TIMEOUT = 5
+DEFAULT_WRITE_TIMEOUT = 30
+
+
+class SerialNoResponse(Exception):
+    pass
+
+
+def get_ports_by_name(device_name: str) -> List[str]:
+    """Returns all serial devices with a given name"""
+    filtered_devices = filter(
+        lambda device: device_name in device[1], list_ports.comports()
+    )
+    device_ports = [device[0] for device in filtered_devices]
+    return device_ports
+
+
+def get_port_by_VID(vid: str) -> Optional[ListPortInfo]:
+    """Returns first serial device with a given VID"""
+    for d in list_ports.comports():
+        if d.vid == vid:
+            return d[0]
+    return None
+
+
+@contextlib.contextmanager
+def serial_with_temp_timeout(
+    serial_connection: Serial, timeout: float
+) -> Iterator[Serial]:
+    """Implements a temporary timeout for a serial connection"""
+    saved_timeout = serial_connection.timeout
+    if timeout is not None:
+        serial_connection.timeout = timeout
+    try:
+        yield serial_connection
+    finally:
+        serial_connection.timeout = saved_timeout
+
+
+def _parse_serial_response(response: bytes, ack: bytes) -> Optional[bytes]:
+    if ack in response:
+        parsed_response = response.split(ack)[0]
+        return parsed_response.strip()
+    else:
+        return None
+
+
+def clear_buffer(serial_connection: Serial) -> None:
+    serial_connection.reset_input_buffer()
+
+
+def _write_to_device_and_return(
+    cmd: str, ack: str, device_connection: Serial, tag: Optional[str] = None
+) -> str:
+    """Writes to a serial device.
+    - Formats command
+    - Wait for ack return
+    - return parsed response"""
+
+    if not tag:
+        tag = device_connection.port
+
+    encoded_write = cmd.encode()
+    encoded_ack = ack.encode()
+    log.debug(f"{tag}: Write -> {encoded_write!r}")
+    device_connection.write(encoded_write)
+    response = device_connection.read_until(encoded_ack)
+    log.debug(f"{tag}: Read <- {response}")
+    if encoded_ack not in response:
+        log.warning(f"{tag}: timed out after {device_connection.timeout}")
+        raise SerialNoResponse(
+            "No response from serial port after {} second(s)".format(
+                device_connection.timeout
+            )
+        )
+    clean_response = _parse_serial_response(response, encoded_ack)
+    if clean_response:
+        return clean_response.decode()
+    return ""
+
+
+def _connect(port_name: str, baudrate: int) -> Serial:
+    ser = serial.serial_for_url(
+        url=port_name, baudrate=baudrate, timeout=DEFAULT_SERIAL_TIMEOUT
+    )
+    log.debug(ser)
+    return ser
+
+
+def _attempt_command_recovery(
+    command: str, ack: str, serial_conn: Serial, tag: Optional[str] = None
+) -> str:
+    """Recovery after following a failed write_and_return() attempt"""
+    if not tag:
+        tag = serial_conn.port
+    with serial_with_temp_timeout(serial_conn, RECOVERY_TIMEOUT) as device:
+        response = _write_to_device_and_return(command, ack, device, tag=tag)
+    if response is None:
+        log.debug(f"{tag}: No valid response during _attempt_command_recovery")
+        raise RuntimeError(
+            "Recovery attempted - no valid serial response "
+            "for command: {} in {} seconds".format(command.encode(), RECOVERY_TIMEOUT)
+        )
+    return response
+
+
+def write_and_return(
+    command: str,
+    ack: str,
+    serial_connection: Serial,
+    timeout: int = DEFAULT_WRITE_TIMEOUT,
+    tag: Optional[str] = None,
+) -> str:
+    """Write a command and return the response"""
+    clear_buffer(serial_connection)
+    with serial_with_temp_timeout(serial_connection, timeout) as device_connection:
+        response = _write_to_device_and_return(command, ack, device_connection, tag)
+    return response
+
+
+def connect(
+    device_name: str, port: Optional[str] = None, baudrate: int = 115200
+) -> Serial:
+    """
+    Creates a serial connection.
+
+    Args:
+        device_name: defaults to 'Smoothieboard'
+        port: the optional port
+        baudrate: integer frequency for serial communication
+
+    Returns:
+        serial.Serial connection
+    """
+    if not port:
+        port = get_ports_by_name(device_name=device_name)[0]
+    log.debug("Device name: {}, Port: {}".format(device_name, port))
+    return _connect(port_name=port, baudrate=baudrate)

opentrons/drivers/smoothie_drivers/__init__.py

@@ -0,0 +1,4 @@
+from .driver_3_0 import SmoothieDriver
+from .simulator import SimulatingDriver
+
+__all__ = ["SmoothieDriver", "SimulatingDriver"]

opentrons/drivers/smoothie_drivers/connection.py

@@ -0,0 +1,51 @@
+import logging
+
+from opentrons.drivers.asyncio.communication import SerialConnection
+
+
+log = logging.getLogger(__name__)
+
+
+class RemoveUnwantedCharactersMixin:
+    """Mixin that removes echoed command and other unwanted characters
+    from the response."""
+
+    def process_raw_response(self, command: str, response: str) -> str:
+        """Process the raw response."""
+        return self._remove_unwanted_characters(command=command, response=response)
+
+    @staticmethod
+    def _remove_unwanted_characters(command: str, response: str) -> str:
+        # smoothieware can enter a weird state, where it repeats back
+        # the sent command at the beginning of its response.
+        # Check for this echo, and strips the command from the response
+        def _is_token_command(_s: str) -> bool:
+            """check if token is a command"""
+            # A single letter token cannot be assumed to be a command.
+            # For example: "M369 L" response is "L:2132121212".
+            return len(_s) > 1
+
+        # Split at spaces.
+        tokens = (c.strip() for c in command.strip().split(" "))
+        # A list of commands to remove from response. Including the entire
+        # command.
+        remove_from_response = [command] + [c for c in tokens if _is_token_command(c)]
+
+        # also removing any inadvertent newline/return characters
+        # this is ok because all data we need from Smoothie is returned on
+        # the first line in the response
+        remove_from_response += ["\r", "\n"]
+        modified_response = str(response)
+
+        for cmd in remove_from_response:
+            modified_response = modified_response.replace(cmd, "")
+
+        if modified_response != response:
+            log.debug(f"Removed characters from response: {response}")
+            log.debug(f"Newly formatted response: {modified_response}")
+
+        return modified_response.strip()
+
+
+class SmoothieConnection(RemoveUnwantedCharactersMixin, SerialConnection):
+    pass