psu-top 0.1.0__tar.gz

psu_top-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oren Collaco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

psu_top-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: psu-top
+Version: 0.1.0
+Summary: htop-style terminal monitor and controller for SCPI bench power supplies (Kiprim DC310S / OWON SPE3103)
+Author: Oren Collaco
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Nero7991/psu-top
+Project-URL: Issues, https://github.com/Nero7991/psu-top/issues
+Keywords: scpi,power-supply,psu,kiprim,owon,tui,bench,serial,instrument
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: Terminals
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial>=3.5
+Requires-Dist: textual>=0.50
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# psu-top
+
+htop-style terminal monitor and controller for SCPI bench power supplies.
+Built for and tested on the Kiprim DC310S (a rebranded OWON SPE3103) over
+USB serial.
+
+```
+ PSU  KIPRIM DC310S  /dev/ttyUSB0  [CONNECTED]   OUTPUT: ON (CV)
+┌─ Voltage ──────────────────────────────────────────────────────────┐
+│  18.063 V   (set 18.100)                                            │
+│                          ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄ │
+└──────────────────────────────────────────────────────────────────────┘
+┌─ Current ──────────────────────────────────────────────────────────┐
+│   1.077 A   (set 2.100)                                             │
+│              ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇ │
+└──────────────────────────────────────────────────────────────────────┘
+ Power:  19.45 W
+ o Output on/off  v Set voltage  c Set current  r Clear graphs  q Quit
+```
+
+The graphs are rolling, oscilloscope-style strip charts: one sample per column,
+newest on the right, scrolling left one column per poll. Heights autoscale to
+the samples currently on screen so low-magnitude signals stay visible.
+
+## Install
+
+```bash
+pip install psu-top
+```
+
+From a checkout, for development:
+
+```bash
+pip install --user -e .
+```
+
+## Usage
+
+```bash
+psu-top                          # defaults: /dev/ttyUSB0, 115200, 0.3 s poll
+psu-top --port /dev/ttyUSB1 --baud 115200 --interval 0.5
+```
+
+Keys: `v` set voltage, `c` set current, `o` toggle output, `r` clear graphs
+(empties the trace and rescales fresh), `q` quit.
+Values are clamped to 0-30 V / 0-10 A before sending.
+
+## Protocol notes (Kiprim DC310S, FW V5.2.0)
+
+- 115200 8N1 over the built-in CH340 USB serial adapter.
+- Commands MUST be terminated with CR LF (`\r\n`). LF alone gets no
+  response from this firmware, although other documentation claims LF
+  suffices. Responses end with CR LF. Invalid commands return `ERR`.
+- Commands used: `*IDN?`, `OUTP?`, `OUTP <0/1>`, `VOLT?`, `VOLT x.xxx`,
+  `CURR?`, `CURR x.xxx`, `MEAS:VOLT?`, `MEAS:CURR?`.
+- CV/CC display is derived (measured current at/near the limit means CC);
+  the device has no documented mode query.
+- Command reference: https://github.com/maximweb/kiprim-dc310s
+
+## Linux note: brltty steals CH340 ports
+
+On Ubuntu, `brltty` claims CH340 adapters and detaches `ttyUSB0`. Fix:
+
+```bash
+sudo systemctl mask brltty-udev.service
+sudo systemctl disable --now brltty.service
+```
+
+## License
+
+MIT

psu_top-0.1.0/README.md

@@ -0,0 +1,71 @@
+# psu-top
+
+htop-style terminal monitor and controller for SCPI bench power supplies.
+Built for and tested on the Kiprim DC310S (a rebranded OWON SPE3103) over
+USB serial.
+
+```
+ PSU  KIPRIM DC310S  /dev/ttyUSB0  [CONNECTED]   OUTPUT: ON (CV)
+┌─ Voltage ──────────────────────────────────────────────────────────┐
+│  18.063 V   (set 18.100)                                            │
+│                          ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄ │
+└──────────────────────────────────────────────────────────────────────┘
+┌─ Current ──────────────────────────────────────────────────────────┐
+│   1.077 A   (set 2.100)                                             │
+│              ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▂▃▄▅▆▇█▇ │
+└──────────────────────────────────────────────────────────────────────┘
+ Power:  19.45 W
+ o Output on/off  v Set voltage  c Set current  r Clear graphs  q Quit
+```
+
+The graphs are rolling, oscilloscope-style strip charts: one sample per column,
+newest on the right, scrolling left one column per poll. Heights autoscale to
+the samples currently on screen so low-magnitude signals stay visible.
+
+## Install
+
+```bash
+pip install psu-top
+```
+
+From a checkout, for development:
+
+```bash
+pip install --user -e .
+```
+
+## Usage
+
+```bash
+psu-top                          # defaults: /dev/ttyUSB0, 115200, 0.3 s poll
+psu-top --port /dev/ttyUSB1 --baud 115200 --interval 0.5
+```
+
+Keys: `v` set voltage, `c` set current, `o` toggle output, `r` clear graphs
+(empties the trace and rescales fresh), `q` quit.
+Values are clamped to 0-30 V / 0-10 A before sending.
+
+## Protocol notes (Kiprim DC310S, FW V5.2.0)
+
+- 115200 8N1 over the built-in CH340 USB serial adapter.
+- Commands MUST be terminated with CR LF (`\r\n`). LF alone gets no
+  response from this firmware, although other documentation claims LF
+  suffices. Responses end with CR LF. Invalid commands return `ERR`.
+- Commands used: `*IDN?`, `OUTP?`, `OUTP <0/1>`, `VOLT?`, `VOLT x.xxx`,
+  `CURR?`, `CURR x.xxx`, `MEAS:VOLT?`, `MEAS:CURR?`.
+- CV/CC display is derived (measured current at/near the limit means CC);
+  the device has no documented mode query.
+- Command reference: https://github.com/maximweb/kiprim-dc310s
+
+## Linux note: brltty steals CH340 ports
+
+On Ubuntu, `brltty` claims CH340 adapters and detaches `ttyUSB0`. Fix:
+
+```bash
+sudo systemctl mask brltty-udev.service
+sudo systemctl disable --now brltty.service
+```
+
+## License
+
+MIT

psu_top-0.1.0/psu_top/__init__.py

@@ -0,0 +1 @@
+"""psu-top: terminal monitor and controller for SCPI bench power supplies."""

psu_top-0.1.0/psu_top/__main__.py

@@ -0,0 +1,39 @@
+"""Command-line entry point for psu-top."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+import serial
+
+from .app import PSUTopApp
+
+
+def parse_args(argv=None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="psu-top",
+        description="Terminal monitor and controller for SCPI bench power supplies",
+    )
+    parser.add_argument("--port", default="/dev/ttyUSB0", help="serial port (default: /dev/ttyUSB0)")
+    parser.add_argument("--baud", type=int, default=115200, help="baud rate (default: 115200)")
+    parser.add_argument("--interval", type=float, default=0.3, help="seconds between polls (default: 0.3)")
+    return parser.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    args = parse_args(argv)
+    if args.interval <= 0:
+        print(f"psu-top: --interval must be positive (got {args.interval})", file=sys.stderr)
+        return 1
+    try:
+        serial.Serial(args.port, args.baud, timeout=1).close()
+    except (serial.SerialException, OSError) as exc:
+        print(f"psu-top: cannot open {args.port}: {exc}", file=sys.stderr)
+        return 1
+    PSUTopApp(args.port, args.baud, args.interval).run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

psu_top-0.1.0/psu_top/app.py

@@ -0,0 +1,344 @@
+"""Textual UI for psu-top."""
+
+from __future__ import annotations
+
+import time
+from collections import deque
+from dataclasses import dataclass
+from typing import ClassVar
+
+import serial
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.segment import Segment
+from rich.style import Style
+from textual.app import App, ComposeResult
+from textual.containers import Vertical
+from textual.widget import Widget
+from textual.widgets import Footer, Input, Static
+from textual.worker import get_current_worker
+
+from .scpi import PSUClient, PSUError
+
+WINDOW_SECONDS = 300.0  # width of the rolling time window shown in each graph
+CC_MARGIN = 0.05        # amps below the limit at which we call the mode CC
+RECONNECT_DELAY = 2.0   # seconds between reopen attempts after a serial error
+
+
+@dataclass
+class Sample:
+    volts: float
+    amps: float
+    set_volts: float
+    set_amps: float
+    output_on: bool
+
+
+class _Bars:
+    """Rich renderable for a rolling column graph.
+
+    ``columns`` is one value (or None for "no data yet") per character cell, one
+    raw sample each. Bar height is the value scaled against ``low``/``high`` --
+    the min and max of the samples currently on screen -- so the scale zooms to
+    the visible data and low currents stay visible.
+    """
+
+    BARS = "▁▂▃▄▅▆▇█"  # eight eighths, index 0 = shortest
+
+    def __init__(
+        self, columns: list[float | None], height: int, low: float, high: float, color
+    ) -> None:
+        self._columns = columns
+        self._height = height
+        self._low = low
+        self._extent = (high - low) or 0.0
+        self._style = Style.from_color(color)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        cols = self._columns
+        height = self._height
+        per_row = len(self.BARS)               # eighths per text row
+        span = per_row * height - 1            # total addressable eighths
+        for row in reversed(range(height)):    # top row first
+            floor = row * per_row
+            for value in cols:
+                if value is None:
+                    yield Segment(" ")
+                    continue
+                # A flat (zero-extent) window sits mid-height rather than on the
+                # floor, so a steady reading reads as a level line, not "empty".
+                ratio = 0.5 if not self._extent else (value - self._low) / self._extent
+                ratio = 0.0 if ratio < 0.0 else 1.0 if ratio > 1.0 else ratio
+                index = int(ratio * span)
+                if index < floor:
+                    yield Segment(" ")
+                elif index >= floor + per_row:
+                    yield Segment("█", self._style)
+                else:
+                    yield Segment(self.BARS[index - floor], self._style)
+            if row > 0:
+                yield Segment.line()
+
+
+class History(Widget):
+    """A rolling, oscilloscope-style bar graph: one sample per column.
+
+    The newest sample sits at the right edge and the trace scrolls one column
+    left per poll. Heights autoscale to the min/max of the samples on screen, so
+    low-magnitude signals stay visible. ``clear()`` empties the trace, which also
+    forces a fresh autoscale as new samples arrive.
+    """
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = {"history--bar"}
+    DEFAULT_CSS = """
+    History > .history--bar { color: $primary; }
+    """
+
+    def __init__(self, capacity: int, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._capacity = max(1, capacity)
+        self._samples: deque[float] = deque(maxlen=self._capacity)
+
+    def add(self, value: float) -> None:
+        self._samples.append(float(value))
+        self.refresh()
+
+    def clear(self) -> None:
+        self._samples.clear()
+        self.refresh()
+
+    def _columns(self, width: int) -> list[float | None]:
+        """One raw sample per column, newest at the right.
+
+        The graph shows the most recent ``width`` samples, so each poll advances
+        the trace exactly one column (rolling rate == update rate) and a sample's
+        height never changes once drawn -- it simply slides left. Older samples
+        beyond the terminal width stay in the buffer but off-screen.
+        """
+        data = list(self._samples)
+        count = len(data)
+        if count >= width:
+            return list(data[-width:])           # newest width samples, right-aligned
+        return [None] * (width - count) + list(data)  # part-full: pad the left
+
+    def render(self) -> RenderResult:
+        width, height = self.size.width, self.size.height
+        if width <= 0 or height <= 0:
+            return ""
+        columns = self._columns(width)
+        visible = [c for c in columns if c is not None]
+        low, high = (min(visible), max(visible)) if visible else (0.0, 1.0)
+        color = self.get_component_styles("history--bar").color
+        return _Bars(columns, height, low, high, color.rich_color)
+
+
+class MeterPanel(Vertical):
+    """One bordered panel: live value + setpoint + rolling history graph."""
+
+    def __init__(self, title: str, unit: str, capacity: int, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.border_title = title
+        self._unit = unit
+        self._graph = History(capacity)
+
+    def compose(self) -> ComposeResult:
+        yield Static("--", classes="meter-value")
+        yield self._graph
+
+    def update_value(self, measured: float, setpoint: float) -> None:
+        self._graph.add(measured)
+        self.query_one(".meter-value", Static).update(
+            f"{measured:8.3f} {self._unit}   (set {setpoint:.3f})"
+        )
+
+    def clear_graph(self) -> None:
+        self._graph.clear()
+
+
+class PSUTopApp(App):
+    """htop-style monitor/controller for the Kiprim DC310S."""
+
+    CSS = """
+    #header { height: 1; background: $boost; }
+    #power { height: 1; }
+    MeterPanel { border: round $primary; height: 9; }
+    .meter-value { height: 1; }
+    History { height: 4; margin: 1 0 0 0; }
+    #entry { display: none; }
+    #entry.visible { display: block; }
+    """
+
+    # Without this, Textual auto-focuses the hidden #entry Input on mount and
+    # it swallows the key bindings.
+    AUTO_FOCUS = None
+
+    BINDINGS = [
+        ("o", "toggle_output", "Output on/off"),
+        ("v", "set_voltage", "Set voltage"),
+        ("c", "set_current", "Set current"),
+        ("r", "clear_graphs", "Clear graphs"),
+        ("q", "quit", "Quit"),
+    ]
+
+    def __init__(self, port: str, baud: int, interval: float) -> None:
+        super().__init__()
+        self._port = port
+        self._baud = baud
+        self._interval = interval
+        # Samples that fill the rolling window at the current poll rate.
+        self._capacity = max(1, round(WINDOW_SECONDS / interval))
+        self._client: PSUClient | None = None
+        self._identity = ""
+        self._last: Sample | None = None
+        self._entry_target: str | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static(" connecting...", id="header")
+        # Stacked, not side by side, so each graph spans the full terminal width.
+        yield MeterPanel("Voltage", "V", self._capacity, id="voltage")
+        yield MeterPanel("Current", "A", self._capacity, id="current")
+        yield Static(id="power")
+        yield Input(id="entry")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self._poll_loop, thread=True, exclusive=True)
+
+    # ---- poll worker (runs in its own thread) ----
+
+    def _poll_loop(self) -> None:
+        worker = get_current_worker()
+        while not worker.is_cancelled:
+            try:
+                if self._client is None:
+                    self._connect()
+                client = self._client
+                sample = Sample(
+                    volts=client.measured_voltage(),
+                    amps=client.measured_current(),
+                    set_volts=client.get_voltage_setpoint(),
+                    set_amps=client.get_current_setpoint(),
+                    output_on=client.get_output(),
+                )
+            except (PSUError, serial.SerialException, OSError):
+                dead, self._client = self._client, None
+                if dead is not None:
+                    try:
+                        dead.close()
+                    except OSError:
+                        pass
+                if worker.is_cancelled:
+                    return
+                self.call_from_thread(self._show_disconnected)
+                self._sleep(worker, RECONNECT_DELAY)
+                continue
+            if worker.is_cancelled:
+                return
+            self.call_from_thread(self._show_sample, sample)
+            self._sleep(worker, self._interval)
+
+    def _connect(self) -> None:
+        ser = serial.Serial(self._port, self._baud, timeout=1)
+        try:
+            client = PSUClient(ser)
+            idn = client.identify()              # e.g. KIPRIM,DC310S,25012662,FV:V5.2.0
+        except Exception:
+            ser.close()                          # don't leak the port if identify fails
+            raise
+        self._identity = " ".join(idn.split(",")[:2])
+        self._client = client
+
+    @staticmethod
+    def _sleep(worker, seconds: float) -> None:
+        """Sleep in small steps so quit is not delayed by a long wait."""
+        deadline = time.monotonic() + seconds
+        while time.monotonic() < deadline and not worker.is_cancelled:
+            time.sleep(0.1)
+
+    # ---- UI updates (run on the app thread via call_from_thread) ----
+
+    def _show_sample(self, sample: Sample) -> None:
+        self._last = sample
+        mode = ""
+        if sample.output_on:
+            mode = " (CC)" if sample.amps >= sample.set_amps - CC_MARGIN else " (CV)"
+        state = ("ON" if sample.output_on else "OFF") + mode
+        self.query_one("#header", Static).update(
+            f" PSU  {self._identity}  {self._port}  [CONNECTED]   OUTPUT: {state}"
+        )
+        self.query_one("#voltage", MeterPanel).update_value(sample.volts, sample.set_volts)
+        self.query_one("#current", MeterPanel).update_value(sample.amps, sample.set_amps)
+        self.query_one("#power", Static).update(
+            f" Power: {sample.volts * sample.amps:6.2f} W"
+        )
+
+    def _show_disconnected(self) -> None:
+        self._last = None
+        self.query_one("#header", Static).update(
+            f" PSU  {self._identity or 'unknown'}  {self._port}  [DISCONNECTED] retrying every {RECONNECT_DELAY:.0f}s"
+        )
+
+    # ---- controls ----
+
+    def _run_control(self, fn) -> None:
+        """Run a control command off the UI thread, surfacing any error.
+
+        Control writes can race a serial disconnect; on failure we notify
+        rather than let the worker die silently (the next poll would also
+        report it, but only after a visible lag).
+        """
+        def task() -> None:
+            try:
+                fn()
+            except (PSUError, serial.SerialException, OSError) as exc:
+                self.call_from_thread(self.notify, f"Command failed: {exc}", severity="error")
+
+        self.run_worker(task, thread=True, exit_on_error=False)
+
+    def action_toggle_output(self) -> None:
+        client, last = self._client, self._last
+        if client is None or last is None:
+            return
+        target = client.output_off if last.output_on else client.output_on
+        self._run_control(target)
+
+    def action_set_voltage(self) -> None:
+        self._prompt("voltage", "V")
+
+    def action_set_current(self) -> None:
+        self._prompt("current", "A")
+
+    def action_clear_graphs(self) -> None:
+        for panel in self.query(MeterPanel):
+            panel.clear_graph()
+
+    def _prompt(self, target: str, unit: str) -> None:
+        if self._client is None:
+            return
+        self._entry_target = target
+        entry = self.query_one("#entry", Input)
+        entry.placeholder = f"new {target} ({unit}) -- Enter to apply, Esc to cancel"
+        entry.value = ""
+        entry.add_class("visible")
+        entry.focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        client, target = self._client, self._entry_target
+        self._dismiss_entry()
+        if client is None or target is None:
+            return
+        try:
+            value = float(event.value)
+        except ValueError:
+            return
+        setter = client.set_voltage if target == "voltage" else client.set_current
+        self._run_control(lambda: setter(value))
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            self._dismiss_entry()
+
+    def _dismiss_entry(self) -> None:
+        self._entry_target = None
+        entry = self.query_one("#entry", Input)
+        entry.remove_class("visible")
+        self.set_focus(None)

psu_top-0.1.0/psu_top/scpi.py

@@ -0,0 +1,96 @@
+"""Serial SCPI client for the Kiprim DC310S (OWON SPE3103).
+
+Protocol (verified live on FW V5.2.0): commands must be terminated with
+CR LF -- LF alone gets no response, despite community docs claiming
+otherwise. Responses end with CR LF. Invalid commands return "ERR".
+Community command reference: https://github.com/maximweb/kiprim-dc310s
+"""
+
+from __future__ import annotations
+
+import threading
+
+TERMINATOR = b"\r\n"
+
+
+class PSUError(Exception):
+    """Raised when the PSU returns ERR, nothing, or garbage."""
+
+
+class PSUClient:
+    """Talks to the PSU over a pyserial-compatible object.
+
+    All serial I/O is serialized through one lock so writes triggered by
+    the UI never interleave with poll-loop reads.
+    """
+
+    VOLTAGE_MAX = 30.0
+    CURRENT_MAX = 10.0
+
+    def __init__(self, ser) -> None:
+        self._ser = ser
+        self._lock = threading.Lock()
+
+    def close(self) -> None:
+        with self._lock:
+            self._ser.close()
+
+    def identify(self) -> str:
+        return self._query("*IDN?")
+
+    def measured_voltage(self) -> float:
+        return self._query_float("MEAS:VOLT?")
+
+    def measured_current(self) -> float:
+        return self._query_float("MEAS:CURR?")
+
+    def get_voltage_setpoint(self) -> float:
+        return self._query_float("VOLT?")
+
+    def get_current_setpoint(self) -> float:
+        return self._query_float("CURR?")
+
+    def get_output(self) -> bool:
+        text = self._query("OUTP?").upper()
+        if text not in ("ON", "OFF"):
+            raise PSUError(f"unexpected response to 'OUTP?': {text!r}")
+        return text == "ON"
+
+    def set_voltage(self, volts: float) -> None:
+        self._write(f"VOLT {_clamp(volts, self.VOLTAGE_MAX):.3f}")
+
+    def set_current(self, amps: float) -> None:
+        self._write(f"CURR {_clamp(amps, self.CURRENT_MAX):.3f}")
+
+    def output_on(self) -> None:
+        self._write("OUTP 1")
+
+    def output_off(self) -> None:
+        self._write("OUTP 0")
+
+    def _query(self, cmd: str) -> str:
+        with self._lock:
+            self._ser.reset_input_buffer()
+            self._ser.write(cmd.encode("ascii") + TERMINATOR)
+            raw = self._ser.read_until(TERMINATOR)
+        text = raw.decode("ascii", errors="replace").strip()
+        if not text:
+            raise PSUError(f"no response to {cmd!r}")
+        if text == "ERR":
+            raise PSUError(f"device returned ERR for {cmd!r}")
+        return text
+
+    def _query_float(self, cmd: str) -> float:
+        text = self._query(cmd)
+        try:
+            return float(text)
+        except ValueError:
+            raise PSUError(f"unparseable response to {cmd!r}: {text!r}") from None
+
+    def _write(self, cmd: str) -> None:
+        with self._lock:
+            self._ser.write(cmd.encode("ascii") + TERMINATOR)
+
+
+def _clamp(value: float, maximum: float) -> float:
+    return max(0.0, min(float(value), maximum))