SCPI-Instrument-Control 2.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

scpi_control/__init__.py

@@ -25,7 +25,7 @@ For automated test report generation:
     from scpi_control.report_generator import ReportGenerator
 """
 
-__version__ = "2.0.0"
+__version__ = "3.0.0"
 
 from scpi_control.exceptions import CommandError, SiglentConnectionError, SiglentError, SiglentTimeoutError
 from scpi_control.oscilloscope import Oscilloscope

scpi_control/channel.py

@@ -4,7 +4,8 @@ import logging
 from typing import TYPE_CHECKING, Literal, Optional
 
 from scpi_control import exceptions
-from scpi_control.scpi_commands import coupling_from_wire, coupling_to_wire
+from scpi_control.models import validate_channel
+from scpi_control.scpi_commands import coupling_from_wire, coupling_to_wire, probe_from_wire, probe_to_wire
 
 if TYPE_CHECKING:
     from scpi_control.oscilloscope import Oscilloscope
@@ -31,10 +32,8 @@ class Channel:
         """
         self._scope = oscilloscope
         self._channel = channel_number
-        self._prefix = f"C{channel_number}"
 
-        if not 1 <= channel_number <= 4:
-            raise exceptions.InvalidParameterError(f"Invalid channel number: {channel_number}. Must be 1-4.")
+        validate_channel(oscilloscope, channel_number)
 
     @property
     def _dialect(self) -> str:
@@ -51,9 +50,10 @@ class Channel:
             True if channel is displayed, False otherwise
         """
         response = self._scope.query(self._cmd("get_channel_display", ch=self._channel))
-        # Response format: "C1:TRA ON" or "C1:TRA OFF"
-        # Extract the last word
-        return "ON" in response.upper()
+        # Response format: "C1:TRA ON"/"C1:TRA OFF" (legacy/modern) or a bare
+        # "1"/"0" numeric select (tektronix SELect:CH<x>? -- TBS p.144)
+        token = response.strip().split()[-1].upper() if response.strip() else ""
+        return token in ("ON", "1")
 
     @enabled.setter
     def enabled(self, value: bool) -> None:
@@ -171,13 +171,18 @@ class Channel:
         Returns:
             Probe ratio (e.g., 1.0 for 1X, 10.0 for 10X)
         """
+        # Probe commands are family-split on Tek (tek_tbs/tek_mso) and absent
+        # from the plain base table; gate before querying so a forced-dialect
+        # variant fallback raises cleanly instead of a raw KeyError.
+        if not self._scope._has_command("get_probe_ratio"):
+            raise exceptions.FeatureNotSupportedError(f"probe ratio is not supported on the {self._dialect} dialect")
         response = self._scope.query(self._cmd("get_probe_ratio", ch=self._channel))
         # Response may include echo like "C1:ATTN 10"
         if ":" in response:
             response = response.split(":", 1)[1]
         if " " in response:
             response = response.split(" ", 1)[1]
-        return float(response.strip())
+        return probe_from_wire(self._dialect, response.strip())
 
     @probe_ratio.setter
     def probe_ratio(self, ratio: float) -> None:
@@ -190,7 +195,14 @@ class Channel:
         """
         if ratio <= 0:
             raise exceptions.InvalidParameterError(f"Probe ratio must be positive: {ratio}")
-        self._scope.write(self._cmd("set_probe_ratio", ch=self._channel, ratio=ratio))
+        if not self._scope._has_command("set_probe_ratio"):
+            raise exceptions.FeatureNotSupportedError(f"probe ratio is not supported on the {self._dialect} dialect")
+        if self._dialect == "tektronix":
+            # Tek speaks probe attenuation as a gain factor (1/ratio); the
+            # tek_tbs/tek_mso family templates use the {gain} placeholder
+            self._scope.write(self._cmd("set_probe_ratio", ch=self._channel, gain=probe_to_wire(self._dialect, ratio)))
+        else:
+            self._scope.write(self._cmd("set_probe_ratio", ch=self._channel, ratio=probe_to_wire(self._dialect, ratio)))
         logger.info(f"Channel {self._channel} probe ratio set to {ratio}X")
 
     @property
@@ -200,9 +212,21 @@ class Channel:
         Returns:
             Bandwidth limit: 'ON', 'OFF', or frequency limit
         """
+        if self._dialect == "lecroy":
+            # BWL? is global: "C1,OFF,C2,20MHZ,..." pairs (MAUI p.7-18). The
+            # real LeCroy <mode> vocabulary is {OFF,20MHZ,200MHZ,...} -- there
+            # is no "ON" token, so any non-OFF wire token maps to the public
+            # "ON" (mirrors the modern/tektronix ON/OFF normalization below).
+            tokens = [t.strip().upper() for t in self._scope.query(self._cmd("get_bandwidth_limit")).split(",")]
+            try:
+                wire = tokens[tokens.index(f"C{self._channel}") + 1]
+            except (ValueError, IndexError):
+                return "OFF"
+            return "OFF" if wire == "OFF" else "ON"
         response = self._scope.query(self._cmd("get_bandwidth_limit", ch=self._channel)).strip().upper()
-        if self._dialect == "modern":
-            # Modern wire tokens are FULL/20M/200M; the API speaks ON/OFF
+        if self._dialect in ("modern", "tektronix"):
+            # Modern wire tokens are FULL/20M/200M; Tek's are FULl/TWENty (or
+            # a hertz value on MSO2) -- both speak ON/OFF at the public layer
             return "OFF" if response == "FULL" else "ON"
         return response
 
@@ -218,6 +242,21 @@ class Channel:
             raise exceptions.InvalidParameterError(f"Invalid bandwidth limit: {limit}. Must be ON, OFF, or FULL.")
         if self._dialect == "modern":
             wire = "FULL" if limit in ("OFF", "FULL") else "20M"
+        elif self._dialect == "tektronix":
+            if limit in ("OFF", "FULL"):
+                wire = "FULL"
+            elif getattr(getattr(self._scope, "model_capability", None), "scpi_variant", None) == "tek_mso":
+                # MSO 2-Series bandwidth vocabulary is {<NR3>|FULl} -- it has no
+                # TWENty keyword, so send 20 MHz as an explicit hertz value
+                # (2 Series MSO PM 077-1776-07 p.2-183).
+                wire = "20E6"
+            else:
+                # TBS1000C accepts the TWEnty keyword (TBS PM 077-1691-01 p.53).
+                wire = "TWENty"
+        elif self._dialect == "lecroy":
+            # LeCroy BWL <mode> vocabulary has no "ON" token -- {OFF,20MHZ,
+            # 200MHZ,...} (MAUI p.7-18). Map public ON to the 20MHz limit.
+            wire = "OFF" if limit in ("OFF", "FULL") else "20MHZ"
         else:
             wire = "OFF" if limit == "FULL" else limit
         self._scope.write(self._cmd("set_bandwidth_limit", ch=self._channel, limit=wire))
@@ -230,8 +269,9 @@ class Channel:
         Returns:
             Unit string (typically 'V' for volts)
         """
-        # legacy-only command; not routed
-        response = self._scope.query(f"{self._prefix}:UNIT?")
+        if not self._scope._has_command("get_channel_unit"):
+            raise exceptions.FeatureNotSupportedError(f"channel unit is not supported on the {self._dialect} dialect")
+        response = self._scope.query(self._cmd("get_channel_unit", ch=self._channel))
         return response.strip()
 
     @unit.setter
@@ -241,7 +281,9 @@ class Channel:
         Args:
             unit: Unit string ('V' for volts, 'A' for amps)
         """
-        self._scope.write(f"{self._prefix}:UNIT {unit}")
+        if not self._scope._has_command("set_channel_unit"):
+            raise exceptions.FeatureNotSupportedError(f"channel unit is not supported on the {self._dialect} dialect")
+        self._scope.write(self._cmd("set_channel_unit", ch=self._channel, unit=unit))
         logger.info(f"Channel {self._channel} unit set to {unit}")
 
     def auto_scale(self) -> None:
@@ -261,16 +303,23 @@ class Channel:
         Returns:
             Dictionary with all channel settings
         """
-        return {
+        config = {
             "channel": self._channel,
             "enabled": self.enabled,
             "coupling": self.coupling,
             "voltage_scale": self.voltage_scale,
             "voltage_offset": self.voltage_offset,
-            "probe_ratio": self.probe_ratio,
-            "bandwidth_limit": self.bandwidth_limit,
-            "unit": self.unit,
         }
+        try:
+            config["probe_ratio"] = self.probe_ratio
+        except exceptions.FeatureNotSupportedError:
+            config["probe_ratio"] = None
+        config["bandwidth_limit"] = self.bandwidth_limit
+        try:
+            config["unit"] = self.unit
+        except exceptions.FeatureNotSupportedError:
+            config["unit"] = None
+        return config
 
     def __repr__(self) -> str:
         """String representation."""

scpi_control/connection/mock/__init__.py

@@ -0,0 +1,5 @@
+"""Mock connection package: shared shell in base, one personality module per vendor."""
+
+from scpi_control.connection.mock.base import MOCK_SCREENSHOT_BMP, MockConnection
+
+__all__ = ["MockConnection", "MOCK_SCREENSHOT_BMP"]

scpi_control/connection/{mock.py → mock/base.py}

@@ -1,55 +1,21 @@
-"""Mock connection implementation for deterministic offline SCPI testing."""
+"""Mock connection shell: constructor/state, connect/disconnect, PSU/AWG/DAQ handling,
+and personality dispatch to the vendor-specific scope write/query/waveform modules."""
 
 from __future__ import annotations
 
 import re
-from typing import Dict, Iterable, List, Optional, Tuple, Union
+from typing import Dict, Iterable, List, Optional, Union
 
 from scpi_control import exceptions
 from scpi_control.connection.base import BaseConnection
+from scpi_control.connection.mock.helpers import MOCK_SCREENSHOT_BMP, _build_ieee_block
+from scpi_control.connection.mock import lecroy, siglent, tektronix
 from scpi_control.models import detect_model_from_idn
 
-
-def _format_scientific(value: float, unit: str) -> str:
-    """Format a numeric value with a unit using Siglent-style scientific notation."""
-    return f"{value:.2E}{unit}"
-
-
-def _format_nr3(value: float) -> str:
-    """Format a bare NR3 numeric value (no unit) as used by modern-dialect queries."""
-    return f"{value:.2E}"
-
-
-def _build_ieee_block(payload: bytes) -> bytes:
-    """Wrap payload in an IEEE-488.2 definite-length block: #<ndigits><length><payload>."""
-    length_str = str(len(payload)).encode()
-    return b"#" + str(len(length_str)).encode() + length_str + payload
-
-
-# Minimal valid 1x1 24bpp BMP, so a mock SCDP? screenshot decodes as a real image.
-MOCK_SCREENSHOT_BMP = bytes.fromhex("424d3a000000000000003600000028000000010000000100000001001800000000000400000000000000000000000000000000000000ffffff00")
-
-
-# Canonical PAVA? measurement values for the legacy dialect (mirrors real
-# hardware where PAVA? is legacy-only; the modern dialect has no equivalent).
-_MOCK_PAVA_VALUES: Dict[str, Tuple[str, str]] = {
-    "PKPK": ("2.000E+00", "V"),
-    "MAX": ("1.000E+00", "V"),
-    "MIN": ("-1.000E+00", "V"),
-    "AMPL": ("2.000E+00", "V"),
-    "TOP": ("1.000E+00", "V"),
-    "BASE": ("-1.000E+00", "V"),
-    "CMEAN": ("0.000E+00", "V"),
-    "MEAN": ("0.000E+00", "V"),
-    "RMS": ("7.070E-01", "V"),
-    "CRMS": ("7.070E-01", "V"),
-    "FREQ": ("1.000E+03", "HZ"),
-    "PER": ("1.000E-03", "S"),
-    "RISE": ("3.500E-05", "S"),
-    "FALL": ("3.500E-05", "S"),
-    "WID": ("5.000E-04", "S"),
-    "NWID": ("5.000E-04", "S"),
-    "DUTY": ("5.000E+01", "%"),
+_PERSONALITIES = {
+    "siglent": siglent,
+    "tektronix": tektronix,
+    "lecroy": lecroy,
 }
 
 
@@ -88,13 +54,16 @@ class MockConnection(BaseConnection):
         daq_mode: bool = False,
         daq_idn: str = "Keysight Technologies,34970A,MY12345678,A.01.02",
         daq_readings: str = "1.234,2.345,3.456",
+        tek_badges: Optional[Dict[int, Dict[str, str]]] = None,
     ):
         super().__init__(host, port, timeout)
         channels = channel_states.keys() if channel_states else range(1, 3)
 
         self.idn = idn
         # Personality: answer only the wire dialect this model actually speaks
-        self.scope_dialect = detect_model_from_idn(idn).dialect
+        capability = detect_model_from_idn(idn)
+        self.scope_dialect = capability.dialect
+        self.scope_vendor = capability.vendor
         self._channel_enabled: Dict[int, bool] = {ch: channel_states.get(ch, True) if channel_states else True for ch in channels}
         self._voltage_scales: Dict[int, float] = {ch: voltage_scales.get(ch, 1.0) if voltage_scales else 1.0 for ch in channels}
         self._voltage_offsets: Dict[int, float] = {ch: voltage_offsets.get(ch, 0.0) if voltage_offsets else 0.0 for ch in channels}
@@ -116,6 +85,25 @@ class MockConnection(BaseConnection):
         self.trigger_level: Dict[int, float] = {ch: 0.0 for ch in channels}
         self.trigger_status: List[str] = trigger_status[:] if trigger_status else ["Stop"]
 
+        # Tektronix wire-vocabulary state (shared across tek_tbs/tek_mso variants)
+        self.tek_stop_after = "RUNSTOP"
+        self.data_source: int = 1
+        self.probe_gains: Dict[int, float] = {ch: 0.1 for ch in channels}
+        self.holdoff_time = 0.0
+        # Measurement badges: slot -> {"type": ..., "source": ...}. Seed via
+        # tek_badges to model badges a user created on the instrument.
+        self.badges: Dict[int, Dict[str, str]] = {n: dict(cfg) for n, cfg in (tek_badges or {}).items()}
+        if self.scope_vendor == "tektronix":
+            # Tek vocabulary differs from both Siglent dialects (guide TEKTRONIX_COMMANDS table)
+            self.trigger_mode = "AUTO"
+            self.trigger_slope = "RISE"
+            self.trigger_source = "CH1"
+            self._channel_coupling = {ch: "DC" for ch in channels}
+            if not trigger_status:
+                # "SAVE" is the Tek TRIGger:STATE? token for stopped; the shared
+                # default ["Stop"] is Siglent vocabulary and not a valid Tek state.
+                self.trigger_status = ["SAVE"]
+
         self.custom_responses = custom_responses or {}
         self.writes: List[str] = []
         self.queries: List[str] = []
@@ -360,102 +348,18 @@ class MockConnection(BaseConnection):
                     self.awg_channels[ch]["enabled"] = enabled
                 return
 
-        # Oscilloscope commands
-        if self.scope_dialect == "modern":
-            if match := re.match(r":CHANnel(\d+):SWITch\s+(ON|OFF)", command, re.IGNORECASE):
-                self._channel_enabled[int(match.group(1))] = match.group(2).upper() == "ON"
-                return
-            if match := re.match(r":CHANnel(\d+):SCALe\s+(.+)", command, re.IGNORECASE):
-                ch = int(match.group(1))
-                self._voltage_scales[ch] = float(match.group(2))
-                self.scale_updates.setdefault(ch, []).append(float(match.group(2)))
-                return
-            if match := re.match(r":CHANnel(\d+):OFFSet\s+(.+)", command, re.IGNORECASE):
-                self._voltage_offsets[int(match.group(1))] = float(match.group(2))
-                return
-            if match := re.match(r":CHANnel(\d+):COUPling\s+(\w+)", command, re.IGNORECASE):
-                self._channel_coupling[int(match.group(1))] = match.group(2).upper()
-                return
-            if match := re.match(r":TIMebase:SCALe\s+(.+)", command, re.IGNORECASE):
-                self.timebase = float(match.group(1))
-                self.timebase_updates.append(self.timebase)
-                return
-            if match := re.match(r":TRIGger:MODE\s+(\w+)", command, re.IGNORECASE):
-                self.trigger_mode = match.group(1)  # stored as wire token, e.g. "NORMal" (guide p.482)
-                if match.group(1).upper() == "SINGLE" and len(self.trigger_status) <= 1:
-                    # Status vocabulary matches real hardware: Ready while armed, Stop when done (same rule as the legacy ARM handler)
-                    self.trigger_status = ["Ready", "Stop"]
-                return
-            if re.match(r":TRIGger:RUN$", command, re.IGNORECASE):
-                self.trigger_mode = "AUTO"
-                return
-            if re.match(r":TRIGger:STOP$", command, re.IGNORECASE):
-                if len(self.trigger_status) <= 1:
-                    self.trigger_status = ["Stop"]
-                return
-            if match := re.match(r":TRIGger:TYPE\s+(\w+)", command, re.IGNORECASE):
-                self.trigger_type = match.group(1).upper()
-                return
-            if match := re.match(r":TRIGger:EDGE:SOURce\s+(\w+)", command, re.IGNORECASE):
-                self.trigger_source = match.group(1).upper()
-                return
-            if match := re.match(r":TRIGger:EDGE:LEVel\s+(.+)", command, re.IGNORECASE):
-                self.trigger_level[1] = float(match.group(1))
-                return
-            if match := re.match(r":TRIGger:EDGE:SLOPe\s+(\w+)", command, re.IGNORECASE):
-                self.trigger_slope = match.group(1)  # wire token, e.g. "RISing" (guide p.494)
-                return
-            if match := re.match(r":TRIGger:EDGE:COUPling\s+(\w+)", command, re.IGNORECASE):
-                self.trigger_coupling = match.group(1)
-                return
-            # Unknown modern writes fall through and are merely recorded,
-            # mirroring real scopes which silently drop unknown commands
-
-        if command.upper().startswith("TDIV "):
-            value = command.split(" ", 1)[1]
-            try:
-                self.timebase = float(value)
-            except ValueError:
-                self.timebase = self.timebase
-            self.timebase_updates.append(self.timebase)
-        elif match := re.match(r"C(\d+):VDIV\s+(.+)", command, re.IGNORECASE):
-            channel = int(match.group(1))
-            value = float(match.group(2))
-            self._voltage_scales[channel] = value
-            self.scale_updates.setdefault(channel, []).append(value)
-        elif match := re.match(r"C(\d+):OFST\s+(.+)", command, re.IGNORECASE):
-            channel = int(match.group(1))
-            value = float(match.group(2))
-            self._voltage_offsets[channel] = value
-        elif match := re.match(r"C(\d+):TRA\s+(ON|OFF)", command, re.IGNORECASE):
-            channel = int(match.group(1))
-            self._channel_enabled[channel] = match.group(2).upper() == "ON"
-        elif match := re.match(r"C(\d+):CPL\s+(\w+)", command, re.IGNORECASE):
-            self._channel_coupling[int(match.group(1))] = match.group(2).upper()
-        elif command.upper().startswith("TRIG_MODE "):
-            self.trigger_mode = command.split(" ", 1)[1].upper()
-        elif command.upper().startswith("TRIG_SELECT "):
-            _, params = command.split(" ", 1)
-            trig_type, _, source = params.split(",")
-            self.trigger_type = trig_type.strip().upper()
-            self.trigger_source = source.strip().upper()
-        elif match := re.match(r"C(\d+):TRSL\s+(\w+)", command, re.IGNORECASE):
-            self.trigger_slope = match.group(2).upper()
-        elif match := re.match(r"C(\d+):TRCP\s+(\w+)", command, re.IGNORECASE):
-            self.trigger_coupling = match.group(2).upper()
-        elif command.upper() == "ARM":
-            # Simulate an acquisition that will eventually stop when no custom sequence is provided.
-            # Status vocabulary matches real hardware: Ready while armed, Stop when done.
-            if len(self.trigger_status) <= 1:
-                self.trigger_status = ["Ready", "Stop"]
-        elif match := re.match(r"C(\d+):TRLV\s+(.+)", command, re.IGNORECASE):
-            channel = int(match.group(1))
-            self.trigger_level[channel] = float(match.group(2))
-        elif match := re.match(r"C(\d+):WF\?", command, re.IGNORECASE):
+        # Oscilloscope commands: C{n}:WF? channel recording is shared across every
+        # scope dialect/vendor (Tek's CURVe? uses data_source instead - Task 9), so
+        # it is recorded here before personality dispatch rather than inside a
+        # single vendor module's write handler.
+        if match := re.match(r"C(\d+):WF\?", command, re.IGNORECASE):
             channel = int(match.group(1))
             self._last_waveform_channel = channel
             self.waveform_requests.append(channel)
 
+        personality = _PERSONALITIES.get(self.scope_vendor, siglent)
+        personality.handle_write(self, command)
+
     def read(self) -> str:
         """Return an empty response for completeness."""
         if not self._connected:
@@ -693,88 +597,10 @@ class MockConnection(BaseConnection):
                     return "CV"
                 return "CV"
 
-        if self.scope_dialect == "modern":
-            if upper == ":TRIGGER:STATUS?":  # enum Arm|Ready|Auto|Trig'd|Stop|Roll, p.483
-                if len(self.trigger_status) > 1:
-                    return self.trigger_status.pop(0)
-                return self.trigger_status[0]
-            if upper == ":TRIGGER:MODE?":  # mixed-case wire token, e.g. "NORMal", p.482
-                return self.trigger_mode
-            if upper == ":TRIGGER:TYPE?":
-                return self.trigger_type
-            if upper == ":TRIGGER:EDGE:SOURCE?":  # bare token, p.495
-                return self.trigger_source
-            if upper == ":TRIGGER:EDGE:SLOPE?":  # wire token e.g. "RISing", p.494
-                return self.trigger_slope
-            if upper == ":TRIGGER:EDGE:COUPLING?":
-                return self.trigger_coupling
-            if upper == ":TRIGGER:EDGE:LEVEL?":  # bare NR3, p.492
-                return _format_nr3(self.trigger_level.get(1, 0.0))
-            if match := re.match(r":CHANNEL(\d+):SWITCH\?", upper):
-                return "ON" if self._channel_enabled.get(int(match.group(1)), True) else "OFF"
-            if match := re.match(r":CHANNEL(\d+):SCALE\?", upper):  # bare NR3, p.58
-                return _format_nr3(self._voltage_scales.get(int(match.group(1)), 1.0))
-            if match := re.match(r":CHANNEL(\d+):OFFSET\?", upper):  # bare NR3, p.56
-                return _format_nr3(self._voltage_offsets.get(int(match.group(1)), 0.0))
-            if match := re.match(r":CHANNEL(\d+):COUPLING\?", upper):  # DC|AC|GND, p.51
-                return self._channel_coupling.get(int(match.group(1)), "DC")
-            if upper == ":TIMEBASE:SCALE?":  # bare NR3, p.476
-                return _format_nr3(self.timebase)
-            if upper == ":ACQUIRE:SRATE?":  # bare NR3, p.46
-                return _format_nr3(self.sample_rate)
-
-        if self.scope_dialect == "legacy":
-            if match := re.match(r"C(\d+):VDIV\?", command, re.IGNORECASE):
-                channel = int(match.group(1))
-                value = self._voltage_scales.get(channel, 1.0)
-                return _format_scientific(value, "V")
-
-            if match := re.match(r"C(\d+):OFST\?", command, re.IGNORECASE):
-                channel = int(match.group(1))
-                value = self._voltage_offsets.get(channel, 0.0)
-                return _format_scientific(value, "V")
-
-            if match := re.match(r"C(\d+):TRA\?", command, re.IGNORECASE):
-                channel = int(match.group(1))
-                return "ON" if self._channel_enabled.get(channel, True) else "OFF"
-
-            if match := re.match(r"C(\d+):CPL\?", command, re.IGNORECASE):
-                return self._channel_coupling.get(int(match.group(1)), "D1M")
-
-            if match := re.match(r"C(\d+):TRLV\?", command, re.IGNORECASE):
-                channel = int(match.group(1))
-                return _format_scientific(self.trigger_level.get(channel, 0.0), "V")
-
-            if re.match(r"C(\d+):TRSL\?", command, re.IGNORECASE):
-                return self.trigger_slope
-
-            if re.match(r"C(\d+):TRCP\?", command, re.IGNORECASE):
-                return self.trigger_coupling
-
-            if upper == "TDIV?":
-                return _format_scientific(self.timebase, "S")
-
-            if upper == "SARA?":
-                return _format_scientific(self.sample_rate, "Sa/s")
-
-            if upper == "SAST?":
-                if len(self.trigger_status) > 1:
-                    return self.trigger_status.pop(0)
-                return self.trigger_status[0]
-
-            if upper == "TRIG_MODE?":
-                return self.trigger_mode
-
-            if upper == "TRIG_SELECT?":
-                return f"{self.trigger_type},SR,{self.trigger_source}"
-
-            if match := re.match(r"PAVA\?\s*(\w+)\s*,\s*C?(\d+)", command, re.IGNORECASE):
-                mtype = match.group(1).upper()
-                channel = match.group(2)
-                entry = _MOCK_PAVA_VALUES.get(mtype)
-                if entry is not None:
-                    value, unit = entry
-                    return f"PAVA {mtype},C{channel},{value}{unit}"
+        personality = _PERSONALITIES.get(self.scope_vendor, siglent)
+        response = personality.handle_query(self, command)
+        if response is not None:
+            return response
 
         if self.psu_mode or self.awg_mode or self.daq_mode:
             return ""
@@ -787,10 +613,6 @@ class MockConnection(BaseConnection):
         """Convenience helper to query multiple commands sequentially."""
         return [self.query(cmd) for cmd in commands]
 
-    def _build_waveform_block(self, payload: bytes) -> bytes:
-        """Construct a minimal Siglent-style block response."""
-        return b"DESC," + _build_ieee_block(payload)
-
     def read_raw(self, size: Optional[int] = None) -> bytes:
         """Return deterministic raw waveform data (or a mock screenshot BMP after SCDP?)."""
         if not self._connected:
@@ -801,6 +623,5 @@ class MockConnection(BaseConnection):
             # scope's SCDP? reply is parsed in screen_capture.py.
             return _build_ieee_block(MOCK_SCREENSHOT_BMP)
 
-        channel = self._last_waveform_channel or next(iter(self._waveform_payloads.keys()))
-        payload = self._waveform_payloads.get(channel, bytes())
-        return self._build_waveform_block(payload)
+        personality = _PERSONALITIES.get(self.scope_vendor, siglent)
+        return personality.build_waveform_response(self)

scpi_control/connection/mock/helpers.py

@@ -0,0 +1,25 @@
+"""Vendor-neutral formatting helpers shared by the mock connection shell and every
+personality module. Lives separately so personality modules never need to import
+from `base` (which imports these helpers), avoiding an import cycle."""
+
+from __future__ import annotations
+
+
+def _format_scientific(value: float, unit: str) -> str:
+    """Format a numeric value with a unit using Siglent-style scientific notation."""
+    return f"{value:.2E}{unit}"
+
+
+def _format_nr3(value: float) -> str:
+    """Format a bare NR3 numeric value (no unit) as used by modern-dialect queries."""
+    return f"{value:.2E}"
+
+
+def _build_ieee_block(payload: bytes) -> bytes:
+    """Wrap payload in an IEEE-488.2 definite-length block: #<ndigits><length><payload>."""
+    length_str = str(len(payload)).encode()
+    return b"#" + str(len(length_str)).encode() + length_str + payload
+
+
+# Minimal valid 1x1 24bpp BMP, so a mock SCDP? screenshot decodes as a real image.
+MOCK_SCREENSHOT_BMP = bytes.fromhex("424d3a000000000000003600000028000000010000000100000001001800000000000400000000000000000000000000000000000000ffffff00")

scpi_control/connection/mock/lecroy.py

@@ -0,0 +1,96 @@
+"""LeCroy MAUI mock personality.
+
+Writes reuse the Siglent legacy handler (Siglent copied LeCroy's command set);
+queries answer in CHDR OFF format: bare values, no unit suffixes.
+"""
+
+import re
+import struct
+from typing import Optional
+
+from scpi_control.connection.mock.helpers import _build_ieee_block, _format_nr3
+from scpi_control.connection.mock.siglent import _MOCK_PAVA_VALUES, handle_write as _legacy_write
+
+_INR_MAP = {"TRIG'D": "1"}  # INR bit 0: new signal acquired
+
+
+def handle_write(conn, command: str) -> bool:
+    upper = command.strip().upper()
+    if upper.startswith("CFMT ") or upper.startswith("CORD ") or upper == "CHDR OFF":
+        return True
+    if upper == "STOP":
+        conn.trigger_mode = "STOP"  # TRMD? reports STOP after a STOP command
+        return True
+    if upper.startswith("BWL "):
+        # Legacy chain has no BWL handler; record as a no-op write explicitly
+        # so the fidelity contract (write returns True => consumed) holds.
+        return True
+    # The legacy chain understands TDIV/VDIV/TRA/CPL/TRIG_* — LeCroy originals.
+    # Its modern branch gates on scope_dialect == "modern", which is False here.
+    return _legacy_write(conn, command)
+
+
+def handle_query(conn, command: str) -> Optional[str]:
+    upper = command.strip().upper()
+
+    if match := re.match(r"C(\d+):VDIV\?", upper):
+        return _format_nr3(conn._voltage_scales.get(int(match.group(1)), 1.0))
+    if match := re.match(r"C(\d+):OFST\?", upper):
+        return _format_nr3(conn._voltage_offsets.get(int(match.group(1)), 0.0))
+    if match := re.match(r"C(\d+):TRA\?", upper):
+        return "ON" if conn._channel_enabled.get(int(match.group(1)), True) else "OFF"
+    if match := re.match(r"C(\d+):CPL\?", upper):
+        return conn._channel_coupling.get(int(match.group(1)), "D1M")
+    if match := re.match(r"C(\d+):TRLV\?", upper):
+        return _format_nr3(conn.trigger_level.get(int(match.group(1)), 0.0))
+    if re.match(r"C(\d+):TRSL\?", upper):
+        return conn.trigger_slope
+    if re.match(r"C(\d+):TRCP\?", upper):
+        return conn.trigger_coupling
+    if match := re.match(r"C(\d+):ATTN\?", upper):
+        return "10"
+    if upper == "TDIV?":
+        return _format_nr3(conn.timebase)
+    if upper == "TRIG_MODE?" or upper == "TRMD?":
+        return conn.trigger_mode
+    if upper == "TRIG_SELECT?" or upper == "TRSE?":
+        return f"{conn.trigger_type},SR,{conn.trigger_source}"
+    if upper == "INR?":
+        if len(conn.trigger_status) > 1:
+            return _INR_MAP.get(conn.trigger_status.pop(0).upper(), "0")
+        return _INR_MAP.get(conn.trigger_status[0].upper(), "0")
+    if upper == "BWL?":
+        return ",".join(f"C{ch},OFF" for ch in sorted(conn._channel_enabled))
+    if upper.startswith("VBS? 'RETURN=APP.ACQUISITION.HORIZONTAL.SAMPLINGRATE'"):
+        return _format_nr3(conn.sample_rate)
+    if match := re.match(r"C(\d+):PAVA\?\s*(\w+)", upper):
+        mtype = match.group(2)
+        entry = _MOCK_PAVA_VALUES.get(mtype)
+        if entry is not None:
+            value, _unit = entry
+            # CHDR OFF suppresses units on LeCroy; native shape is <param>,<value>,<state>
+            return f"{mtype},{value},OK"
+    return None
+
+
+def build_waveform_response(conn) -> bytes:
+    """Construct a LeCroy WAVEDESC + sample-array block (WF? ALL, CORD LO)."""
+    channel = conn._last_waveform_channel or next(iter(conn._waveform_payloads))
+    codes = conn._waveform_payloads.get(channel, bytes())
+    gain = conn._voltage_scales.get(channel, 1.0) / 25.0  # mirror Siglent scaling for comparable volts
+    desc = bytearray(346)
+    desc[0:8] = b"WAVEDESC"
+    struct.pack_into("<h", desc, 32, 0)
+    struct.pack_into("<i", desc, 36, 346)
+    struct.pack_into("<i", desc, 40, 0)
+    # TRIGTIME_ARRAY (offset 48) and RIS_TIME_ARRAY (offset 52) lengths: 0 for
+    # this single-shot mock (the bytearray is already zero-filled; packed
+    # explicitly to document the layout parse_wavedesc now skips).
+    struct.pack_into("<i", desc, 48, 0)
+    struct.pack_into("<i", desc, 52, 0)
+    struct.pack_into("<i", desc, 116, len(codes))
+    struct.pack_into("<f", desc, 156, gain)
+    struct.pack_into("<f", desc, 160, conn._voltage_offsets.get(channel, 0.0))
+    struct.pack_into("<f", desc, 176, 1.0 / conn.sample_rate)
+    struct.pack_into("<d", desc, 180, 0.0)
+    return _build_ieee_block(bytes(desc) + codes)