plotdeck 1.0.0__py3-none-any.whl

plotdeck/core/transport.py

@@ -0,0 +1,375 @@
+"""Serial transport layer.
+
+The transport is swappable: :class:`SerialTransport` talks to a real port,
+while :class:`MockTransport` provides a self-contained demo machine. Both
+deliver complete lines through plain callbacks, which keeps this module free
+of Qt imports.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from contextlib import suppress
+from typing import Any
+
+from .grbl_protocol import BAUD_RATE, UNO_RESET_DELAY_S
+
+
+class TransportError(RuntimeError):
+    pass
+
+
+class Transport(ABC):
+    """Common interface for anything that can exchange lines with GRBL."""
+
+    on_line: Callable[[str], None] | None = None
+    on_error: Callable[[str], None] | None = None
+    on_closed: Callable[[str], None] | None = None
+    on_open: Callable[[], None] | None = None
+
+    @property
+    @abstractmethod
+    def is_open(self) -> bool: ...
+
+    @abstractmethod
+    def open(self) -> None: ...
+
+    @abstractmethod
+    def close(self) -> None: ...
+
+    @abstractmethod
+    def write(self, data: bytes) -> None: ...
+
+    # Convenience helpers ---------------------------------------------------
+    def send_line(self, line: str) -> None:
+        self.write(line.encode("utf-8") + b"\n")
+
+    def send_realtime(self, byte: bytes) -> None:
+        self.write(byte)
+
+    def _emit_line(self, line: str) -> None:
+        callback = self.on_line
+        if callback is not None:
+            # Never let a consumer exception kill the reader thread.
+            with suppress(Exception):
+                callback(line)
+
+    def _emit_error(self, message: str) -> None:
+        callback = self.on_error
+        if callback is not None:
+            with suppress(Exception):
+                callback(message)
+
+    def _emit_closed(self, reason: str) -> None:
+        callback = self.on_closed
+        if callback is not None:
+            with suppress(Exception):
+                callback(reason)
+
+    def _emit_open(self) -> None:
+        callback = self.on_open
+        if callback is not None:
+            with suppress(Exception):
+                callback()
+
+
+class SerialTransport(Transport):
+    """pyserial transport on a background thread.
+
+    The Uno resets when the port opens, so the reader waits
+    :data:`UNO_RESET_DELAY_S` before flushing and asking for a status report.
+    The GRBL welcome banner then tells the controller the link is really up.
+    """
+
+    def __init__(
+        self,
+        port: str,
+        baud: int = BAUD_RATE,
+        reset_delay: float = UNO_RESET_DELAY_S,
+    ) -> None:
+        self.port = port
+        self.baud = baud
+        self.reset_delay = reset_delay
+        self._serial: Any = None
+        self._thread: threading.Thread | None = None
+        self._stop = threading.Event()
+        self._write_lock = threading.Lock()
+        self._open = False
+
+    @property
+    def is_open(self) -> bool:
+        return self._open
+
+    def open(self) -> None:
+        if self._thread is not None and self._thread.is_alive():
+            return
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._run, name=f"serial-{self.port}", daemon=True)
+        self._thread.start()
+
+    def _run(self) -> None:
+        import serial
+
+        try:
+            self._serial = serial.Serial(self.port, self.baud, timeout=0.05)
+        except Exception as exc:  # serial.SerialException and OSError
+            self._open = False
+            self._emit_error(f"Could not open {self.port}: {exc}")
+            self._emit_closed(str(exc))
+            return
+
+        self._open = True
+        try:
+            time.sleep(self.reset_delay)
+            if self._stop.is_set():
+                return
+            with self._write_lock:
+                self._serial.write(b"\r\n\r\n")
+                self._serial.flush()
+            # Start status polling only after the Uno has rebooted, so the
+            # first '?' does not land in the bootloader.
+            self._emit_open()
+        except Exception as exc:  # noqa: BLE001
+            self._emit_error(str(exc))
+
+        while not self._stop.is_set():
+            try:
+                data = self._serial.readline()
+            except Exception as exc:  # unplugged or closed
+                if not self._stop.is_set():
+                    self._emit_error(f"Serial connection lost: {exc}")
+                    self._emit_closed(str(exc))
+                break
+            if not data:
+                continue
+            decoded = data.decode("utf-8", errors="replace").strip("\r\n ")
+            if decoded:
+                self._emit_line(decoded)
+
+    def close(self) -> None:
+        self._stop.set()
+        thread = self._thread
+        if thread is not None and thread is not threading.current_thread():
+            thread.join(timeout=1.5)
+        self._thread = None
+        self._open = False
+        serial_port = self._serial
+        self._serial = None
+        if serial_port is not None:
+            with suppress(Exception):
+                serial_port.close()
+
+    def write(self, data: bytes) -> None:
+        serial_port = self._serial
+        if not self._open or serial_port is None:
+            raise TransportError("Serial port is not open.")
+        with self._write_lock:
+            try:
+                serial_port.write(data)
+                serial_port.flush()
+            except Exception as exc:  # noqa: BLE001
+                self._emit_error(f"Write failed: {exc}")
+                raise TransportError(str(exc)) from exc
+
+
+class MockTransport(Transport):
+    """A tiny GRBL stand-in so the UI can be explored without hardware.
+
+    It implements the same character-counting contract as the real firmware:
+    lines are queued and acknowledged one at a time, status reports work, and
+    ``!``/``~`` change the state.
+    """
+
+    def __init__(self, line_delay: float = 0.004) -> None:
+        self._delay = line_delay
+        self._open = False
+        self._state = "Idle"
+        self._pos = [0.0, 0.0, 0.0]
+        self._feed = 0.0
+        self._spindle = 0.0
+        self._settings = {
+            0: "10",
+            1: "25",
+            2: "0",
+            3: "0",
+            4: "0",
+            5: "0",
+            6: "0",
+            10: "3",
+            11: "0.010",
+            12: "0.002",
+            13: "0",
+            20: "0",
+            21: "0",
+            22: "1",
+            23: "0",
+            24: "25.000",
+            25: "500.000",
+            26: "250",
+            27: "1.000",
+            30: "1000",
+            31: "0",
+            32: "0",
+            100: "250.000",
+            101: "250.000",
+            102: "250.000",
+            110: "500.000",
+            111: "500.000",
+            112: "500.000",
+            120: "10.000",
+            121: "10.000",
+            122: "10.000",
+            130: "200.000",
+            131: "200.000",
+            132: "200.000",
+        }
+        self._thread: threading.Thread | None = None
+        self._worker: threading.Thread | None = None
+        self._stop = threading.Event()
+        self._lock = threading.Lock()
+        self._pending: list[int] = []
+        self._lines: list[str] = []
+
+    @property
+    def is_open(self) -> bool:
+        return self._open
+
+    def open(self) -> None:
+        self._open = True
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._run, name="mock-grbl", daemon=True)
+        self._thread.start()
+        self._worker = threading.Thread(
+            target=self._process_lines, name="mock-grbl-lines", daemon=True
+        )
+        self._worker.start()
+
+    def _run(self) -> None:
+        time.sleep(0.2)
+        self._emit_open()
+        self._emit_line("Grbl 1.1h ['$' for help]")
+        while not self._stop.is_set():
+            time.sleep(0.05)
+
+    def _process_lines(self) -> None:
+        # Line commands are acknowledged asynchronously, like real firmware.
+        while not self._stop.is_set():
+            with self._lock:
+                line = self._lines.pop(0) if self._lines else None
+            if line is None:
+                time.sleep(0.002)
+                continue
+            self._dispatch(line)
+            time.sleep(self._delay)
+
+    def close(self) -> None:
+        self._stop.set()
+        thread = self._thread
+        if thread is not None and thread is not threading.current_thread():
+            thread.join(timeout=1.0)
+        worker = self._worker
+        if worker is not None and worker is not threading.current_thread():
+            worker.join(timeout=1.0)
+        self._thread = None
+        self._worker = None
+        if self._open:
+            self._open = False
+            self._emit_closed("Disconnected")
+
+    def write(self, data: bytes) -> None:
+        if not self._open:
+            raise TransportError("Mock transport is not open.")
+        with self._lock:
+            for byte in data:
+                self._handle_byte(byte)
+
+    def _handle_byte(self, byte: int) -> None:
+        if byte == 0x3F:  # '?'
+            self._emit_status()
+        elif byte == 0x21:  # '!'
+            self._state = "Hold:0"
+        elif byte == 0x7E:  # '~'
+            self._state = "Idle"
+        elif byte == 0x18:  # soft reset
+            self._state = "Idle"
+            self._feed = 0.0
+            self._pending.clear()
+            self._lines.clear()
+            threading.Timer(0.05, lambda: self._emit_line("Grbl 1.1h ['$' for help]")).start()
+        elif byte == 0x85:
+            self._state = "Idle"
+        elif byte in (0x0A, 0x0D):
+            line = bytes(self._pending).decode("utf-8", errors="replace").strip()
+            self._pending.clear()
+            if line:
+                self._lines.append(line)
+        else:
+            self._pending.append(byte)
+
+    def _emit_status(self) -> None:
+        pos = "MPos:{:.3f},{:.3f},{:.3f}".format(*self._pos)
+        self._emit_line(
+            f"<{self._state}|{pos}|FS:{self._feed:.0f},{self._spindle:.0f}"
+            f"|Bf:0,127|Ov:100,100,100>"
+        )
+
+    # A line is dispatched when its newline arrives; handled in write().
+    def _dispatch(self, line: str) -> None:
+        text = line.strip()
+        if not text:
+            return
+        if text == "?":
+            self._emit_status()
+            return
+        if text == "$$":
+            for key in sorted(self._settings):
+                self._emit_line(f"${key}={self._settings[key]}")
+            self._emit_line("ok")
+            return
+        if text == "$I":
+            self._emit_line("[VER:1.1h.20190825:]")
+            self._emit_line("[OPT:V,15,128]")
+            self._emit_line("ok")
+            return
+        if text.startswith("$J="):
+            self._emit_line("ok")
+            return
+        if text == "$H":
+            self._state = "Home"
+            self._pos = [0.0, 0.0, 0.0]
+            self._state = "Idle"
+            self._emit_line("ok")
+            return
+        if text in ("$X", "$C", "$G", "$#"):
+            self._emit_line("ok")
+            return
+        if text.startswith("G0") or text.startswith("G1"):
+            import re
+
+            for axis, value in re.findall(r"([XYZ])([-+]?\d*\.?\d+)", text):
+                index = "XYZ".index(axis)
+                self._pos[index] = float(value)
+            self._emit_line("ok")
+            return
+        if text.startswith("M3") or text.startswith("M5"):
+            self._emit_line("ok")
+            return
+        self._emit_line("ok")
+
+
+def list_serial_ports() -> list[tuple[str, str]]:
+    """Return USB-looking serial ports as ``(device, description)``."""
+    try:
+        from serial.tools import list_ports
+    except ImportError:
+        return []
+    ports: list[tuple[str, str]] = []
+    for info in list_ports.comports():
+        device = info.device
+        if any(token in device for token in ("usbmodem", "usbserial", "wchusbserial")):
+            ports.append((device, info.description or device))
+    ports.sort()
+    return ports

plotdeck/ui/__init__.py

@@ -0,0 +1 @@
+"""PySide6 user interface for PlotDeck."""

plotdeck/ui/connection_panel.py

@@ -0,0 +1,139 @@
+"""Connection controls shown in the main toolbar."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import (
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QToolButton,
+    QWidget,
+)
+
+from ..core.controller import MachineController
+
+
+class ConnectionPanel(QWidget):
+    connectRequested = Signal(str, int, bool)
+    disconnectRequested = Signal()
+
+    def __init__(self, parent=None) -> None:  # noqa: ANN001
+        super().__init__(parent)
+        self.setObjectName("Panel")
+        self._connected = False
+        self._connecting = False
+
+        self._port = QComboBox()
+        self._port.setMinimumWidth(200)
+        self._port.setToolTip("Serial port")
+        refresh = QToolButton()
+        refresh.setText("⟳")
+        refresh.setToolTip("Refresh ports")
+        refresh.clicked.connect(self.refresh_ports)
+
+        self._baud = QComboBox()
+        self._baud.setEditable(True)
+        for baud in ("9600", "57600", "115200", "230400", "250000"):
+            self._baud.addItem(baud)
+        self._baud.setCurrentText("115200")
+        self._baud.setFixedWidth(90)
+        self._baud.setToolTip("Baud rate")
+
+        self._connect = QPushButton("Connect")
+        self._connect.setObjectName("Primary")
+        self._connect.setMinimumWidth(96)
+        self._connect.clicked.connect(self.toggle)
+
+        demo = QToolButton()
+        demo.setText("Demo")
+        demo.setToolTip("Connect to a simulated GRBL machine (no hardware)")
+        demo.clicked.connect(self._demo)
+
+        self._status = QLabel("")
+        self._status.setObjectName("Muted")
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(5)
+        layout.addWidget(QLabel("Port"))
+        layout.addWidget(self._port)
+        layout.addWidget(refresh)
+        layout.addWidget(QLabel("Baud"))
+        layout.addWidget(self._baud)
+        layout.addWidget(self._connect)
+        layout.addWidget(demo)
+        layout.addWidget(self._status)
+
+        self.refresh_ports()
+
+    def refresh_ports(self) -> None:
+        current = self._port.currentData()
+        self._port.clear()
+        ports = MachineController.available_ports()
+        for device, description in ports:
+            label = device if description == device else f"{device}  ·  {description}"
+            self._port.addItem(label, device)
+        if not ports:
+            self._port.addItem("No USB serial ports found", "")
+        if current:
+            index = self._port.findData(current)
+            if index >= 0:
+                self._port.setCurrentIndex(index)
+
+    def select_port(self, port: str) -> None:
+        if not port:
+            return
+        index = self._port.findData(port)
+        if index >= 0:
+            self._port.setCurrentIndex(index)
+        elif port.upper() != "DEMO":
+            self._port.insertItem(0, port, port)
+            self._port.setCurrentIndex(0)
+
+    def baud(self) -> int:
+        try:
+            return int(self._baud.currentText())
+        except ValueError:
+            return 115200
+
+    def set_baud(self, baud: int) -> None:
+        self._baud.setCurrentText(str(baud))
+
+    def toggle(self) -> None:
+        if self._connected:
+            self._connecting = True
+            self._connect.setEnabled(False)
+            self._connect.setText("Disconnecting…")
+            self.disconnectRequested.emit()
+            return
+        port = self._port.currentData()
+        if not port:
+            self._status.setText("No port selected")
+            return
+        self._connecting = True
+        self._connect.setEnabled(False)
+        self._connect.setText("Connecting…")
+        self.connectRequested.emit(port, self.baud(), False)
+
+    def _demo(self) -> None:
+        self._connecting = True
+        self._connect.setEnabled(False)
+        self._connect.setText("Connecting…")
+        self.connectRequested.emit("DEMO", self.baud(), True)
+
+    def set_connected(self, connected: bool, port: str = "") -> None:
+        self._connected = connected
+        self._connecting = False
+        self._connect.setEnabled(True)
+        self._connect.setText("Disconnect" if connected else "Connect")
+        self._status.setText(port if connected else "")
+        self._port.setEnabled(not connected)
+        self._baud.setEnabled(not connected)
+
+    def set_error(self, message: str) -> None:
+        self._connecting = False
+        self._connect.setEnabled(True)
+        self._connect.setText("Connect")
+        self._status.setText(message)

plotdeck/ui/console.py

@@ -0,0 +1,171 @@
+"""Serial console with colour-coded traffic and command history."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QColor, QKeyEvent, QTextCharFormat, QTextCursor
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPlainTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..core.grbl_protocol import ResponseKind
+from .theme import MONO_FONT, tokens
+
+
+class ConsoleInput(QLineEdit):
+    submitted = Signal(str)
+
+    def __init__(self, parent=None) -> None:  # noqa: ANN001
+        super().__init__(parent)
+        self._history: list[str] = []
+        self._index = 0
+        self.setPlaceholderText("Send a command (↑/↓ for history)")
+        self.setClearButtonEnabled(True)
+        self.returnPressed.connect(self._submit)
+
+    def _submit(self) -> None:
+        text = self.text().strip()
+        if not text:
+            return
+        self._history.append(text)
+        self._history = self._history[-200:]
+        self._index = len(self._history)
+        self.submitted.emit(text)
+        self.clear()
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:  # noqa: N802
+        if event.key() == Qt.Key.Key_Up and self._history:
+            self._index = max(0, self._index - 1)
+            self.setText(self._history[self._index])
+            return
+        if event.key() == Qt.Key.Key_Down and self._history:
+            self._index = min(len(self._history), self._index + 1)
+            self.setText("" if self._index == len(self._history) else self._history[self._index])
+            return
+        super().keyPressEvent(event)
+
+
+class Console(QWidget):
+    commandSubmitted = Signal(str)
+
+    def __init__(self, token: dict[str, str] | None = None, parent=None) -> None:  # noqa: ANN001
+        super().__init__(parent)
+        self._token = token or tokens()
+        self._hide_status = True
+        self.setObjectName("Panel")
+
+        self._view = QPlainTextEdit()
+        self._view.setReadOnly(True)
+        self._view.setMaximumBlockCount(5000)
+        self._view.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        font = self._view.font()
+        font.setFamily(MONO_FONT.split(",")[0].replace('"', "").strip())
+        font.setPointSize(12)
+        self._view.setFont(font)
+
+        self._input = ConsoleInput()
+        self._input.submitted.connect(self._on_submit)
+        self._autoscroll = QCheckBox("Autoscroll")
+        self._autoscroll.setChecked(True)
+        self._hide_polls = QCheckBox("Hide status polls")
+        self._hide_polls.setChecked(True)
+        self._hide_polls.toggled.connect(self._set_hide_status)
+        clear = QPushButton("Clear")
+        clear.clicked.connect(self._view.clear)
+        self._count_label = QLabel("")
+        self._count_label.setObjectName("Muted")
+
+        controls = QHBoxLayout()
+        controls.setContentsMargins(0, 0, 0, 0)
+        controls.addWidget(self._autoscroll)
+        controls.addWidget(self._hide_polls)
+        controls.addWidget(self._count_label, 1)
+        controls.addWidget(clear)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(4)
+        layout.addLayout(controls)
+        layout.addWidget(self._view, 1)
+        layout.addWidget(self._input)
+
+        self._formats = {
+            "sent": self._format(self._token["accent"]),
+            "ok": self._format(self._token["idle"]),
+            "error": self._format(self._token["alarm"], bold=True),
+            "alarm": self._format(self._token["alarm"], bold=True),
+            "message": self._format(self._token["muted"]),
+            "status": self._format(self._token["muted"]),
+            "other": self._format(self._token["text"]),
+            "banner": self._format(self._token["hold"], bold=True),
+        }
+        self._line_count = 0
+
+    @staticmethod
+    def _format(color: str, bold: bool = False) -> QTextCharFormat:
+        style = QTextCharFormat()
+        style.setForeground(QColor(color))
+        if bold:
+            style.setFontWeight(700)
+        return style
+
+    def set_token(self, token: dict[str, str]) -> None:
+        self._token = token
+        self._formats.update(
+            {
+                "sent": self._format(token["accent"]),
+                "ok": self._format(token["idle"]),
+                "error": self._format(token["alarm"], bold=True),
+                "alarm": self._format(token["alarm"], bold=True),
+                "message": self._format(token["muted"]),
+                "status": self._format(token["muted"]),
+                "other": self._format(token["text"]),
+                "banner": self._format(token["hold"], bold=True),
+            }
+        )
+
+    def _set_hide_status(self, value: bool) -> None:
+        self._hide_status = value
+
+    def append(self, kind: ResponseKind | str, text: str) -> None:
+        key = kind.value if isinstance(kind, ResponseKind) else kind
+        if key == "status" and self._hide_status:
+            return
+        if key == "other" and not text.strip():
+            return
+        if key == "banner":
+            text = text or "(reset)"
+        prefix = ">" if key == "sent" else "<"
+        self._insert(f"{prefix} {text}", key)
+        self._line_count += 1
+        if self._line_count % 5 == 0:
+            self._count_label.setText(f"{self._line_count} lines")
+
+    def _insert(self, text: str, key: str) -> None:
+        bar = self._view.verticalScrollBar()
+        at_bottom = bar.value() >= bar.maximum() - 4
+        cursor = self._view.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        cursor.insertText(text + "\n", self._formats.get(key, self._formats["other"]))
+        if self._autoscroll.isChecked() or at_bottom:
+            bar.setValue(bar.maximum())
+
+    def _on_submit(self, text: str) -> None:
+        self.append("sent", text)
+        self.commandSubmitted.emit(text)
+
+    def set_enabled(self, enabled: bool) -> None:
+        self._input.setEnabled(enabled)
+
+    def focus_input(self) -> None:
+        self._input.setFocus()
+
+    def log(self, text: str) -> None:
+        self.append("message", text)