et43 0.1.0__py3-none-any.whl

et43/__init__.py

@@ -0,0 +1,21 @@
+"""Human-friendly Python client for EastTester ET43x LCR meters (ET430-ET433)."""
+
+from .client import ET43, Idn, Reading
+from .enums import (
+    DisplayPage,
+    Equivalent,
+    PrimaryMode,
+    SecondaryMode,
+    Speed,
+)
+
+__all__ = [
+    "ET43",
+    "DisplayPage",
+    "Equivalent",
+    "Idn",
+    "PrimaryMode",
+    "Reading",
+    "SecondaryMode",
+    "Speed",
+]

et43/client.py

@@ -0,0 +1,440 @@
+"""Minimal SCPI client for EastTester ET43x LCR meters (incl. ET433).
+
+The ET43x series exposes a virtual serial port (USB CDC) and speaks a small
+SCPI dialect.  This module exposes the device commands as named properties and
+returns raw measurement values; higher-level helpers live in ``scripts/``.
+"""
+
+import contextlib
+import os
+import time
+from collections.abc import Generator
+from dataclasses import dataclass
+from typing import NamedTuple, Self, override
+
+import serial
+from serial.serialutil import Timeout
+from serial.tools import list_ports
+
+from .enums import (
+    DisplayPage,
+    Equivalent,
+    PrimaryMode,
+    SecondaryMode,
+    Speed,
+)
+
+CALIBRATION_TIMEOUT = 45.0
+"""Default maximum wait for the ``CORR:EXEC`` acknowledgement, in seconds."""
+
+
+@dataclass(frozen=True, slots=True)
+class Idn:
+    """Contents of ``*IDN?``."""
+
+    manufacturer: str
+    model: str
+    firmware: str
+    hardware: str
+    serial: str
+    raw: str
+
+    @override
+    def __str__(self) -> str:
+        return (
+            f"{self.manufacturer} {self.model} (firmware {self.firmware}, hardware {self.hardware}, S/N {self.serial})"
+        )
+
+
+class Reading(NamedTuple):
+    """One ``FETCH?`` result.
+
+    A tuple, so ``primary, secondary = lcr.fetch()`` works.  ``secondary`` is
+    ``None`` when the instrument returns a single value (e.g. in DCR mode).
+    """
+
+    primary: float
+    secondary: float | None
+
+
+class ET43:
+    """Client for an EastTester ET43x LCR meter.
+
+    Parameters
+    ----------
+    port:
+        A ready-to-use, already open ``serial.Serial`` instance.  The client
+        takes ownership: ``close()`` (also called by the context manager)
+        always closes it.
+
+    The constructor performs no I/O: it only takes ownership of the port.
+    Use :meth:`open` for discovery and port creation, then
+    :meth:`auto_remote` for a block that enters remote mode and always returns
+    the instrument to local control.
+
+    Notes
+    -----
+    The client is not thread-safe.  One instance is meant to be used by one
+    thread at a time; serialize access externally if needed.
+    """
+
+    def __init__(self, port: serial.Serial) -> None:
+        self.port = port
+        # A single byte read after a CR when it was not followed by LF.
+        # It belongs to the next response and must be consumed by the next
+        # ``_read()`` call.  One byte is enough because ``_read()`` consumes
+        # the stream one character at a time.
+        self._pending_byte: bytes | None = None
+
+    # ------------------------------------------------------------------
+    # Connection handling
+
+    @classmethod
+    def open(
+        cls,
+        port: str | None = None,
+        baudrate: int = 115_200,
+        *,
+        timeout: float = 2.0,
+        exclusive: bool = True,
+    ) -> ET43:
+        """Open a serial port and return a connected client.
+
+        When ``port`` is omitted, :meth:`discover` is used.  The returned client
+        owns the port and closes it in ``close()``.
+        """
+        if port is None:
+            port, baudrate = cls.discover(baudrates=(baudrate, 9_600))
+
+        link = serial.Serial(
+            port=port,
+            baudrate=baudrate,
+            timeout=timeout,
+            write_timeout=timeout,
+            exclusive=exclusive and os.name == "posix",
+        )
+
+        return cls(link)
+
+    @classmethod
+    def discover(
+        cls,
+        ports: list[str] | None = None,
+        baudrates: tuple[int, ...] = (115_200, 9_600),
+        timeout: float = 0.8,
+    ) -> tuple[str, int]:
+        """Find a connected ET43x and return ``(port, baudrate)``.
+
+        Only USB serial adapters are probed by default (the ET433 uses a
+        CH340).  Pass explicit ``ports`` to search something else.
+        """
+        if ports is None:
+            candidates = list(list_ports.comports())
+            selected: list[str] = [
+                item.device
+                for item in candidates
+                if item.vid == 0x1A86
+                or "CH340" in (item.description or "").upper()
+                or "USB SERIAL" in (item.description or "").upper()
+            ]
+            ports = selected if selected else [item.device for item in candidates]
+
+        if not ports:
+            raise ConnectionError("no serial ports found")
+
+        for device in ports:
+            for baudrate in baudrates:
+                try:
+                    options: dict[str, object] = {
+                        "port": device,
+                        "baudrate": baudrate,
+                        "timeout": timeout,
+                    }
+                    if os.name == "posix":
+                        options["exclusive"] = True
+                    with serial.Serial(**options) as link:  # type: ignore[arg-type]
+                        time.sleep(0.1)
+                        link.reset_input_buffer()
+                        link.write(b"*IDN?\n")
+                        link.flush()
+                        time.sleep(0.15)
+                        answer = link.read(512)
+                except serial.SerialException, OSError:
+                    continue
+                if b"ET43" in answer.upper():
+                    return device, baudrate
+
+        raise ConnectionError(
+            "no ET43x device answered; checked " + ", ".join(f"{port} @ {baud}" for port in ports for baud in baudrates)
+        )
+
+    def close(self) -> None:
+        """Close the serial port."""
+        self.port.close()
+
+    @property
+    def is_open(self) -> bool:
+        """Whether the serial port is currently open."""
+        return bool(self.port.is_open)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_) -> None:
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Low-level serial / SCPI plumbing
+
+    def _write(self, command: str) -> None:
+        """Write a command without reading a response."""
+        self._pending_byte = None
+        self.port.reset_input_buffer()
+        self.port.write((command + "\n").encode("ascii"))
+        self.port.flush()
+
+    def _read(self, timeout: float | None = None) -> str:
+        """Read one response; raise on protocol errors or missing data.
+
+        ``timeout=None`` uses the port's configured timeout.  Only calibration
+        passes an explicit value, because ``CORR:EXEC`` takes tens of seconds.
+        """
+        port_timeout = self.port.timeout
+        if timeout is not None:
+            self.port.timeout = timeout
+        deadline = Timeout(self.port.timeout)
+        buffer = bytearray()
+
+        try:
+            while True:
+                if self._pending_byte is not None:
+                    char = self._pending_byte
+                    self._pending_byte = None
+                else:
+                    char = self.port.read(1)
+
+                if not char:
+                    break
+                if char in (b"\r", b"\n"):
+                    if buffer:
+                        # A normal device sends CRLF; consume the LF part
+                        # so the next read does not see it as an empty line.
+                        if char == b"\r" and self.port.in_waiting:
+                            extra = self.port.read(1)
+                            if extra and extra != b"\n":
+                                self._pending_byte = extra
+                        break
+                    # Ignore leading / duplicated terminators.
+                    continue
+                buffer.extend(char)
+                if deadline.expired():
+                    break
+        finally:
+            if timeout is not None:
+                self.port.timeout = port_timeout
+
+        response = buffer.decode("ascii", errors="replace").strip()
+        # ET433 answers "cmd err" / "exec err"; ET44.py also expects
+        # "execu err" from the ET44/ET45, so match any "... err" reply.
+        if response.endswith(" err"):
+            raise RuntimeError(response)
+        if not response:
+            raise TimeoutError("no response (timeout)")
+        return response
+
+    def _request(self, command: str, *, timeout: float | None = None) -> str:
+        """Write a command and read its response.
+
+        ``timeout`` overrides the port timeout for this response only.
+        """
+        self._write(command)
+        return self._read(timeout)
+
+    def _command(self, command: str, *, timeout: float | None = None) -> None:
+        """Write a command and require an ``exec success`` acknowledgement.
+
+        ``timeout`` overrides the port timeout for this response only.
+        """
+        response = self._request(command, timeout=timeout)
+        if response != "exec success":
+            raise RuntimeError(f"unexpected response to {command!r}: {response!r}")
+
+    # ------------------------------------------------------------------
+    # Identification and display
+
+    @property
+    def idn(self) -> Idn:
+        """Query ``*IDN?`` and return the instrument identification."""
+        raw = self._request("*IDN?")
+        fields = [item.strip() for item in raw.split(",")]
+        if len(fields) != 5:
+            raise ValueError(f"cannot parse *IDN? response: {raw!r}")
+        return Idn(*fields, raw=raw)
+
+    @property
+    def display_page(self) -> DisplayPage:
+        """Current display page: ``MEAS`` or ``SYST``."""
+        return DisplayPage.from_string(self._request("DISP:PAGE?"))
+
+    @display_page.setter
+    def display_page(self, page: DisplayPage) -> None:
+        self._command(f"DISP:PAGE {page.value}")
+
+    # ------------------------------------------------------------------
+    # Measurement configuration
+
+    @property
+    def mode(self) -> PrimaryMode:
+        """Primary parameter: ``AUTO``, ``R``, ``C``, ``L``, ``Z``, ``DCR``, ``ECAP``."""
+        return PrimaryMode.from_string(self._request("FUNC:IMP:A?"))
+
+    @mode.setter
+    def mode(self, mode: PrimaryMode) -> None:
+        self._command(f"FUNC:IMP:A {mode.value}")
+
+    @property
+    def secondary(self) -> SecondaryMode:
+        """Secondary parameter: ``X``, ``D``, ``Q``, ``THR`` (phase) or ``ESR``."""
+        return SecondaryMode.from_string(self._request("FUNC:IMP:B?"))
+
+    @secondary.setter
+    def secondary(self, mode: SecondaryMode) -> None:
+        self._command(f"FUNC:IMP:B {mode.value}")
+
+    @property
+    def equivalent(self) -> Equivalent:
+        """Equivalent circuit: ``SER`` (series) or ``PAR`` (parallel)."""
+        return Equivalent.from_string(self._request("FUNC:IMP:EQU?"))
+
+    @equivalent.setter
+    def equivalent(self, eq: Equivalent) -> None:
+        self._command(f"FUNC:IMP:EQU {eq.value}")
+
+    @property
+    def frequency(self) -> float:
+        """Test frequency in Hz."""
+        return float(self._request("FREQ?"))
+
+    @frequency.setter
+    def frequency(self, value: float) -> None:
+        self._command(f"FREQ {value:g}")
+
+    @property
+    def level_mv(self) -> float:
+        """Test signal level in mV."""
+        return float(self._request("VOLT?"))
+
+    @level_mv.setter
+    def level_mv(self, value: float) -> None:
+        self._command(f"VOLT {value:g}")
+
+    @property
+    def bias_mv(self) -> float:
+        """Internal DC bias in mV."""
+        return float(self._request("BIAS:VOLT?"))
+
+    @bias_mv.setter
+    def bias_mv(self, value: float) -> None:
+        self._command(f"BIAS:VOLT {value:g}")
+
+    @property
+    def speed(self) -> Speed:
+        """Measurement speed: ``FAST``, ``MED`` or ``SLOW``."""
+        return Speed.from_string(self._request("APER?"))
+
+    @speed.setter
+    def speed(self, speed: Speed) -> None:
+        self._command(f"APER {speed.value}")
+
+    @property
+    def measurement_range(self) -> int | None:
+        """Current impedance range in ohms, or ``None`` for automatic range."""
+        answer = self._request("FUNC:IMP:RANGE?")
+        return None if answer == "AUTO" else int(answer)
+
+    @measurement_range.setter
+    def measurement_range(self, value: int | None) -> None:
+        command = "AUTO" if value is None else str(value)
+        self._command(f"FUNC:IMP:RANGE {command}")
+
+    @property
+    def relative_mode(self) -> bool:
+        """Whether relative (deviation) measurement mode is enabled."""
+        return self._request("FUNC:DEV:MODE?") == "ON"
+
+    @relative_mode.setter
+    def relative_mode(self, value: bool) -> None:
+        self._command(f"FUNC:DEV:MODE {'ON' if value else 'OFF'}")
+
+    # ------------------------------------------------------------------
+    # Measurements and control
+
+    def fetch(self) -> Reading:
+        """Read one ``FETCH?`` response as :class:`Reading`.
+
+        The instrument returns either one value (e.g. in DCR mode) or two.
+        Modes and units are not part of the response, so no extra queries are
+        made.  ``secondary`` is ``None`` when the device returns one value.
+        """
+        answer = self._request("FETCH?")
+        # Verified on ET433 V2.00.2414.001: values are comma-separated
+        # ("2.820165e+04,6.536892e+02").
+        match [float(value) for value in answer.split(",")]:
+            case [primary]:
+                return Reading(primary, None)
+            case [primary, secondary]:
+                return Reading(primary, secondary)
+        raise ValueError(f"cannot parse FETCH? response: {answer!r}")
+
+    def calibrate(self, *, timeout: float = CALIBRATION_TIMEOUT) -> None:
+        """Run open- or short-circuit correction (depends on the fixture).
+
+        The instrument decides whether it sees an open or a short, so connect
+        the appropriate fixture first.  Repeat once for open and once for short.
+        **This overwrites the open/short correction data.**
+
+        The command takes tens of seconds and answers ``exec success`` when
+        done.  The method waits up to ``timeout`` seconds (default
+        :data:`CALIBRATION_TIMEOUT`, 45 s) for that acknowledgement.
+        """
+        self._command("CORR:EXEC", timeout=timeout)
+
+    def remote(self) -> None:
+        """Enter remote mode (front panel locked)."""
+        self._command("SYST:REMOTE")
+
+    def local(self) -> None:
+        """Return the instrument to local (front-panel) control."""
+        # SYST:LOCAL is not acknowledged by the firmware.
+        self._write("SYST:LOCAL")
+
+    @contextlib.contextmanager
+    def auto_remote(self) -> Generator[Self]:
+        """Use remote mode for the duration of the block and close the port.
+
+        Sends ``SYST:REMOTE`` on entry and ``SYST:LOCAL`` on exit, including
+        when the block raises, then closes the serial port.  This keeps the
+        front panel unlocked after the session::
+
+            with ET43.open().auto_remote() as lcr:
+                ...
+
+        ``SYST:LOCAL`` is also sent when ``SYST:REMOTE`` itself fails: the
+        instrument may have applied it and only the acknowledgement was lost.
+        When the block (or entering remote) raises, a failure of
+        ``SYST:LOCAL`` is suppressed so the original error propagates.
+
+        The port is closed on exit, so call this right on :meth:`open` rather
+        than on a client you intend to keep using afterwards.
+        """
+        with self:
+            try:
+                self.remote()
+                yield self
+            except BaseException:
+                # Best effort: do not mask the original error.
+                with contextlib.suppress(Exception):
+                    self.local()
+                raise
+            else:
+                self.local()

et43/enums.py

@@ -0,0 +1,83 @@
+"""Strongly typed instrument settings."""
+from enum import StrEnum
+from typing import Self
+
+
+class ParsedUnit(StrEnum):
+    """Base for SCPI enums that can be parsed from short or long tokens."""
+
+    @classmethod
+    def _matches(cls, text: str, member: Self) -> bool:
+        """Whether *text* names *member*; subclasses may tighten this."""
+        return text == member.name or text.startswith(member.value)
+
+    @classmethod
+    def from_string(cls, value: str | int | Self) -> Self:
+        """Match a short, long, or exact SCPI token to a member."""
+        if isinstance(value, cls):
+            return value
+
+        text = str(value).strip().upper()
+        for member in cls:
+            if cls._matches(text, member):
+                return member
+
+        choices = ", ".join(member.value for member in cls)
+        raise ValueError(f"{cls.__name__} must be one of {choices}")
+
+
+class SecondaryMode(ParsedUnit):
+    """Secondary measurement parameter."""
+
+    X = "X"
+    D = "D"
+    Q = "Q"
+    THR = "THR"
+    ESR = "ESR"
+
+
+class PrimaryMode(ParsedUnit):
+    """Primary measurement parameter."""
+
+    AUTO = "AUTO"
+    R = "R"
+    C = "C"
+    L = "L"
+    Z = "Z"
+    DCR = "DCR"
+    ECAP = "ECAP"
+
+
+class Speed(ParsedUnit):
+    """Measurement speed."""
+
+    FAST = "FAST"
+    MED = "MED"
+    SLOW = "SLOW"
+
+
+class Equivalent(ParsedUnit):
+    """Series or parallel equivalent circuit.
+
+    EastTester firmware (ET43x, ET44x/ET45x) spells parallel as ``PALlel``:
+    it rejects ``PAR`` and reports ``PALlel``. The member is named ``PAR``,
+    but its value is the token the instrument actually accepts.
+    """
+
+    SER = "SER"
+    # "PAL" is not a typo here — it is EastTester's typo. Their SCPI manual
+    # (ET44/ET45, shared firmware lineage with ET43x) defines the keyword as
+    # "PALlel" (sic, a misspelling of "PARallel"). By SCPI rules the short form
+    # is the uppercase prefix, hence "PAL". The firmware enforces it: verified on
+    # a real ET433 (V2.00.2414.001), "FUNC:IMP:EQU PAR" is rejected and
+    # "FUNC:IMP:EQU?" answers "PALlel". Other vendors use their own syntax
+    # (e.g. Keysight encodes series/parallel in FUNC:IMP:TYPE CPD/CSRS), so we
+    # just match EastTester. The member is still called PAR for readability.
+    PAR = "PAL"
+
+
+class DisplayPage(ParsedUnit):
+    """Front-panel display page as its SCPI token."""
+
+    MEAS = "MEAS"
+    SYST = "SYST"

et43-0.1.0.dist-info/METADATA

@@ -0,0 +1,317 @@
+Metadata-Version: 2.4
+Name: et43
+Version: 0.1.0
+Summary: Human-friendly Python client for EastTester ET43x LCR meters (ET430-ET433)
+Keywords: lcr,lcr-meter,scpi,easttester,et43,et433,et43x,pyserial,instrument
+Author: Vyacheslav Mayorov
+Author-email: Vyacheslav Mayorov <vyacheslav.mayorov@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Hardware
+Classifier: Typing :: Typed
+Requires-Dist: pyserial>=3.5
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/acc15/et43
+Project-URL: Repository, https://github.com/acc15/et43
+Project-URL: Issues, https://github.com/acc15/et43/issues
+Description-Content-Type: text/markdown
+
+# et43
+
+A human-friendly Python client for **EastTester ET43x** handheld LCR meters
+(ET430/430B/431/432/**ET433**) over their USB virtual serial port.
+
+> Unofficial, not affiliated with EastTester / Hangzhou Zhongchuang.
+
+Instead of raw SCPI strings you get typed properties and methods: `mode`,
+`frequency`, `level_mv`, `equivalent`, `fetch()` and so on.
+
+- Single dependency: [`pyserial`](https://pypi.org/project/pyserial/) (no PyVISA).
+- Fully typed (`py.typed`).
+- Tested against a real ET433 (firmware `V2.00.2414.001`); see
+  [Firmware quirks](#firmware-quirks).
+
+### ET44x / ET45x
+
+The benchtop ET44x/ET45x series speaks a very similar SCPI dialect, so most of
+the client may work there too, but it has not been tested. Known differences,
+based on the vendor's ET44/ET45 SCPI manual and the
+[ET44.py](https://github.com/philpagel/ET44.py) driver:
+
+- auto range is `FUNC:IMP:RANGe:AUTO ON|OFF` there, while the ET433 needs
+  `FUNC:IMP:RANGE AUTO`, so `measurement_range` will likely fail;
+- ET44.py sends `THETA` for phase, which the ET433 rejects (it needs `THR`);
+- the default baud rate is 9600 (`discover()` tries it as well).
+
+Reports from ET44x/ET45x owners are welcome.
+
+## Installation
+
+```bash
+pip install et43
+# or
+uv add et43
+```
+
+Requires Python 3.14+.
+
+## Quick start
+
+```python
+from et43 import ET43, Equivalent, PrimaryMode, SecondaryMode
+
+with ET43.open("/dev/ttyUSB0").auto_remote() as lcr:
+    print(lcr.idn)
+
+    # Capacitance and ESR at 1 kHz, 1 V test level, series model
+    lcr.mode = PrimaryMode.C
+    lcr.secondary = SecondaryMode.ESR
+    lcr.frequency = 1_000
+    lcr.level_mv = 1_000
+    lcr.equivalent = Equivalent.SER
+
+    primary, secondary = lcr.fetch()
+    print(primary, secondary)  # 1.234e-06 0.5
+```
+
+Without a port name the client looks for the instrument itself:
+
+```python
+lcr = ET43.open()  # auto-discovery, tries 115200 and 9600 baud
+```
+
+`ET43.open()` is a convenience factory: it creates and configures a
+`serial.Serial` and hands it to the client. If you already have a port object,
+pass it directly:
+
+```python
+import serial
+from et43 import ET43
+
+link = serial.Serial("/dev/ttyUSB0", 115200, timeout=2)
+
+with ET43(link).auto_remote() as lcr:
+    primary, secondary = lcr.fetch()
+```
+
+The client always owns the port it is given: `close()` and leaving a `with`
+block close it, even if you created the `serial.Serial` yourself. The response
+timeout is taken from `link.timeout` (2 seconds if it is `None`). The port
+object is available as `lcr.port`, and the device name as `lcr.port.port`.
+
+The `ET43(link)` constructor performs no I/O. The first exchange happens on
+`remote()`, `fetch()` or another explicit call.
+
+On POSIX the port is locked with `flock` by default, so a second process gets
+`serial.SerialException` instead of corrupting the exchange. Disable this with
+`ET43.open(..., exclusive=False)`.
+
+## Settings
+
+Every setting can be read and written:
+
+```python
+from et43 import DisplayPage, Equivalent, PrimaryMode, SecondaryMode, Speed
+
+lcr.mode = PrimaryMode.C
+lcr.secondary = SecondaryMode.ESR
+lcr.frequency = 10_000  # Hz
+lcr.level_mv = 600  # mV
+lcr.bias_mv = 100  # mV
+lcr.equivalent = Equivalent.SER
+lcr.speed = Speed.MED
+lcr.measurement_range = None  # None = AUTO, a number = range in ohms
+lcr.relative_mode = True
+lcr.display_page = DisplayPage.SYST
+```
+
+Enum properties (`mode`, `secondary`, `equivalent`, `speed`, `display_page`)
+accept enum members only, and their getters return enum members. They are
+`StrEnum`s, so comparing with a string still works: `lcr.mode == "C"`.
+
+`measurement_range` reads as `int | None`: `None` means `AUTO`, otherwise it is
+the range resistance in ohms.
+
+`frequency`, `level_mv` and `bias_mv` read as `float`, because SCPI returns them
+in NR3 format. In practice the ET433 works in 1 Hz / 1 mV steps.
+
+The client does not validate ranges: values are sent to the instrument as is.
+Valid ranges depend on the model, and the instrument decides how to handle an
+invalid value. For example, the ET433 silently ignores an out-of-range frequency
+or bias, and answers `exec err` to an invalid level or measurement range.
+
+Parsing helpers on the enums:
+
+```python
+DisplayPage.SYST  # "SYST", the SCPI token; the instrument answers "SYSTem"
+PrimaryMode.from_string("c")  # PrimaryMode.C
+PrimaryMode.from_string("Cp")  # PrimaryMode.C (older firmware answers)
+Speed.from_string("MEDium")  # Speed.MED (instrument answer)
+```
+
+## Measurements
+
+`fetch()` sends exactly one `FETCH?` query and returns a `Reading`, a
+two-field `NamedTuple`. Unpack it or use the field names:
+
+```python
+primary, secondary = lcr.fetch()
+
+reading = lcr.fetch()
+print(reading.primary, reading.secondary)
+```
+
+- `primary` is always a `float`.
+- `secondary` is a `float` or `None`: in `DCR` mode, for example, the
+  instrument returns a single value. The tuple always has two items, so
+  `primary, secondary = ...` works in every mode.
+
+`FETCH?` does not report the mode or units, so the client makes no extra
+queries. Set the mode, the equivalent circuit and other parameters through
+properties:
+
+```python
+import time
+
+lcr.mode = PrimaryMode.C
+lcr.secondary = SecondaryMode.ESR
+lcr.frequency = 1_000
+
+time.sleep(0.5)  # let the instrument settle
+primary, secondary = lcr.fetch()
+```
+
+`fetch()` neither configures the instrument nor waits: it is a single query.
+Measurement loops and frequency sweeps are left to your code; see
+[`scripts/`](https://github.com/acc15/et43/tree/master/scripts) in the repository for examples.
+
+## Remote and local mode
+
+Neither `ET43.open()` nor `ET43(link)` switches the instrument to remote.
+There are two ways to use the client:
+
+- a plain `with` block: the instrument stays in local mode;
+- `auto_remote()`: remote mode for the duration of the block, a guaranteed
+  return to local mode however the block ends, then the port is closed.
+
+```python
+with ET43.open("/dev/ttyUSB0") as lcr:
+    print(lcr.fetch())  # local mode
+
+with ET43.open("/dev/ttyUSB0").auto_remote() as lcr:
+    print(lcr.fetch())  # remote mode; SYST:LOCAL and close() afterwards
+```
+
+`auto_remote()` sends `SYST:REMOTE` on entry and `SYST:LOCAL` on exit, also when
+the block raises. This matters: in remote mode the front panel is locked, and it
+must not stay locked after your program ends. If an error occurs while
+returning to local mode after another error, the original error is the one you
+see. Call it right on `open()`, since it closes the port on exit. To keep the
+connection open across blocks, call `remote()` and `local()` yourself.
+
+In local mode the instrument answers queries (`FETCH?`, `FREQ?` and so on) but
+**ignores configuration commands**. The client reports this as an error rather
+than pretending the setting was applied:
+
+```python
+with ET43.open("/dev/ttyUSB0") as lcr:
+    print(lcr.fetch())  # queries work
+    lcr.frequency = 10_000  # raises TimeoutError in local mode
+```
+
+## Calibration
+
+```python
+lcr.calibrate()  # CORR:EXEC
+```
+
+The instrument detects what is connected, open or short, by itself. Connect open
+leads and calibrate, then short the leads and calibrate again.
+**This overwrites the stored open/short correction data.**
+
+`calibrate()` waits up to 45 seconds for the `exec success` acknowledgement
+(a real ET433 takes about 45 seconds). The timeout can be changed:
+
+```python
+lcr.calibrate(timeout=60)
+```
+
+## Thread safety
+
+The client is not thread-safe: use one instance from one thread. If several
+threads need the instrument, serialize calls with your own `threading.Lock`,
+for example around `fetch()` and property writes.
+
+## Firmware quirks
+
+Verified on a real ET433 with firmware `V2.00.2414.001`:
+
+- **Frequency:** 10–100000 Hz. 10 Hz really works and gives correct C/ESR on a
+  2.2 µF electrolytic capacitor. Out-of-range values are ignored: the instrument
+  answers `exec success` but keeps the old frequency. The ET432 range differs.
+- **Bias:** 0–1000 mV. The older PDF says 0–500 mV, but the V2 manual and the
+  instrument allow 0–1000 mV. Out-of-range values are ignored, fractional
+  values are truncated to whole millivolts.
+- **ECAP mode** enables an internal 1 V bias, which may stay on after switching
+  to another mode. Check `lcr.bias_mv` if it matters.
+- **Level:** 0–1100 mV in whole millivolts. `1101`, negative and fractional
+  values (including `0.001` mV) are rejected with `exec err`.
+- **Baud rate:** 115200. The manual mentions 9600, so `discover()` tries both.
+- **`FETCH?`** returns **two** comma-separated values (`primary,secondary`),
+  while the older SCPI PDF describes four. In `DCR` mode it returns **one**
+  value, and `Reading.secondary` is `None`. Mode and units are not included.
+- **Line terminators** vary between responses (`\n` and `\r`); the reader
+  accepts both.
+- **Parallel equivalent circuit** is spelled `PAL`: `FUNC:IMP:EQU PAR` is
+  rejected, and `FUNC:IMP:EQU?` answers `SERial` or `PALlel`. This is an
+  EastTester misspelling of "parallel", shared by the ET44x/ET45x and present
+  in their SCPI manual. The API member is `Equivalent.PAR`, and its value is
+  `"PAL"`, the token the instrument accepts. `from_string` understands `PAR`,
+  `PAL` and `PALlel`.
+- **Phase:** `FUNC:IMP:B THETA` is rejected; use `THR`. Phase is returned in
+  **degrees**.
+- **Auto range:** `FUNC:IMP:RANGE:AUTO` does not work; the correct form is
+  `FUNC:IMP:RANGE AUTO`.
+- **`AUTO` mode** does not report which parameter was actually measured, and
+  `fetch()` returns bare numbers. Set the mode explicitly (`C`, `L`, `R`, `Z`)
+  if you need units and meaningful labels.
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/) and
+[just](https://github.com/casey/just).
+
+```bash
+uv sync       # create .venv with the package and dev tools
+just check    # ty + ruff + pytest
+just build    # check, then build sdist and wheel into dist/
+```
+
+The tests do not need an instrument. The example scripts do:
+
+```bash
+uv run scripts/basic.py
+uv run scripts/sweep_csv.py
+```
+
+Project layout:
+
+```
+src/et43/
+  client.py     # ET43: transport, settings, fetch, remote/local
+  enums.py      # PrimaryMode, SecondaryMode, Speed, Equivalent, DisplayPage
+scripts/        # usage examples (not part of the package)
+tests/
+```
+
+## License
+
+[MIT](https://github.com/acc15/et43/blob/master/LICENSE)

et43-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+et43/__init__.py,sha256=ok40r1j-Tz5w9kHGJZ3Y-Osfum8Rf9PL_dQULmVQpg0,368
+et43/client.py,sha256=V1x4cTBHTnzfzJbca4-1cwTYp0uoAOVTlYvkpelOkDk,15463
+et43/enums.py,sha256=gEv1HNZp22UdAhMSiSbftl8HLIM2ysHH6f9RWEHAKSg,2401
+et43/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+et43-0.1.0.dist-info/licenses/LICENSE,sha256=hMN05qI_9ROg7FMr8r69SMFy7g1hUscyc0kHhyzYDLo,1075
+et43-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+et43-0.1.0.dist-info/METADATA,sha256=Dl5hQmEJ0xyoZE5uDY8H7Ktc6Zh5AX9MN4l_TbU0Oxc,11317
+et43-0.1.0.dist-info/RECORD,,

et43-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.7
+Root-Is-Purelib: true
+Tag: py3-none-any

et43-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyacheslav Mayorov
+
+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.