SCPI-Instrument-Control 1.1.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__ = "1.1.0"
+__version__ = "3.0.0"
 
 from scpi_control.exceptions import CommandError, SiglentConnectionError, SiglentError, SiglentTimeoutError
 from scpi_control.oscilloscope import Oscilloscope

scpi_control/automation.py

@@ -63,19 +63,21 @@ class DataCollector:
     def __init__(
         self,
         host: str,
-        port: int = 5024,
+        port: int = 5025,
         timeout: float = 5.0,
         connection: Optional[BaseConnection] = None,
+        dialect: Optional[str] = None,
     ):
         """Initialize data collector.
 
         Args:
             host: IP address or hostname of the oscilloscope
-            port: TCP port for SCPI communication (default: 5024)
+            port: TCP port for SCPI communication (default: 5025, the Siglent raw SCPI socket; 5024 is the telnet-style port with prompts and is not recommended)
             timeout: Command timeout in seconds (default: 5.0)
             connection: Optional connection implementation (e.g., MockConnection for offline tests)
+            dialect: Optional SCPI dialect override passed to Oscilloscope ("legacy" or "modern"; None auto-detects)
         """
-        self.scope = Oscilloscope(host, port, timeout, connection=connection)
+        self.scope = Oscilloscope(host, port, timeout, connection=connection, dialect=dialect)
         self._connected = False
 
     def connect(self) -> None:
@@ -472,19 +474,21 @@ class TriggerWaitCollector:
     def __init__(
         self,
         host: str,
-        port: int = 5024,
+        port: int = 5025,
         timeout: float = 5.0,
         connection: Optional[BaseConnection] = None,
+        dialect: Optional[str] = None,
     ):
         """Initialize trigger wait collector.
 
         Args:
             host: IP address or hostname of the oscilloscope
-            port: TCP port for SCPI communication
+            port: TCP port for SCPI communication (default: 5025, the Siglent raw SCPI socket; 5024 is the telnet-style port with prompts and is not recommended)
             timeout: Command timeout in seconds
             connection: Optional connection implementation (e.g., MockConnection for offline tests)
+            dialect: Optional SCPI dialect override passed to Oscilloscope ("legacy" or "modern"; None auto-detects)
         """
-        self.collector = DataCollector(host, port, timeout, connection=connection)
+        self.collector = DataCollector(host, port, timeout, connection=connection, dialect=dialect)
 
     def __enter__(self):
         """Context manager entry."""
@@ -505,6 +509,11 @@ class TriggerWaitCollector:
     ) -> Optional[Dict[int, WaveformData]]:
         """Wait for a trigger event and capture waveform.
 
+        If the trigger mode has been set to NORMAL beforehand (e.g. via
+        ``trigger.set_mode('NORMAL')``), that mode is preserved and the wait
+        completes on the first trigger event. In any other mode, the scope is
+        switched to SINGLE and armed for a one-shot acquisition.
+
         Args:
             channels: List of channel numbers to capture
             max_wait: Maximum time to wait for trigger in seconds
@@ -526,16 +535,23 @@ class TriggerWaitCollector:
             ...     if data:
             ...         print("Trigger captured!")
         """
-        # Set to NORMAL trigger mode
-        self.collector.scope.trigger.mode = "NORM"
-        self.collector.scope.trigger_single()
+        # Honor a user-configured NORMAL trigger mode; otherwise arm a
+        # one-shot SINGLE acquisition. trigger.mode is dialect-normalized.
+        current_mode = self.collector.scope.trigger.mode
+
+        if current_mode == "NORM":
+            # NORMAL mode re-arms after every trigger and never reports
+            # STOP, so watch for the trigger event itself.
+            done_states = {"TRIGD", "STOP"}
+        else:
+            self.collector.scope.trigger_single()
+            done_states = {"STOP"}
 
         start_time = time.time()
         while (time.time() - start_time) < max_wait:
-            # Check trigger status
-            status = self.collector.scope.query(":TRIG:STAT?").strip()
+            status = self.collector.scope.acquisition_status()
 
-            if status == "Stop":
+            if status in done_states:
                 # Trigger occurred, capture waveform
                 logger.info("Trigger detected!")
                 waveforms = {}

scpi_control/channel.py

@@ -4,6 +4,8 @@ import logging
 from typing import TYPE_CHECKING, Literal, Optional
 
 from scpi_control import exceptions
+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
@@ -30,10 +32,15 @@ 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:
+        return getattr(self._scope, "dialect", None) or "legacy"
+
+    def _cmd(self, name: str, **kwargs) -> str:
+        return self._scope._get_command(name, **kwargs)
 
     @property
     def enabled(self) -> bool:
@@ -42,10 +49,11 @@ class Channel:
         Returns:
             True if channel is displayed, False otherwise
         """
-        response = self._scope.query(f"{self._prefix}:TRA?")
-        # Response format: "C1:TRA ON" or "C1:TRA OFF"
-        # Extract the last word
-        return "ON" in response.upper()
+        response = self._scope.query(self._cmd("get_channel_display", ch=self._channel))
+        # 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:
@@ -55,7 +63,7 @@ class Channel:
             value: True to display channel, False to hide
         """
         state = "ON" if value else "OFF"
-        self._scope.write(f"{self._prefix}:TRA {state}")
+        self._scope.write(self._cmd("set_channel_display", ch=self._channel, state=state))
         logger.info(f"Channel {self._channel} {'enabled' if value else 'disabled'}")
 
     def enable(self) -> None:
@@ -73,8 +81,7 @@ class Channel:
         Returns:
             Coupling mode: 'DC', 'AC', or 'GND'
         """
-        response = self._scope.query(f"{self._prefix}:CPL?")
-        return response.upper().strip()
+        return coupling_from_wire(self._dialect, self._scope.query(self._cmd("get_coupling", ch=self._channel)))
 
     @coupling.setter
     def coupling(self, mode: CouplingType) -> None:
@@ -86,7 +93,7 @@ class Channel:
         mode = mode.upper()
         if mode not in ["DC", "AC", "GND"]:
             raise exceptions.InvalidParameterError(f"Invalid coupling mode: {mode}. Must be DC, AC, or GND.")
-        self._scope.write(f"{self._prefix}:CPL {mode}")
+        self._scope.write(self._cmd("set_coupling", ch=self._channel, coupling=coupling_to_wire(self._dialect, mode)))
         logger.info(f"Channel {self._channel} coupling set to {mode}")
 
     @property
@@ -96,7 +103,7 @@ class Channel:
         Returns:
             Voltage scale in volts/division
         """
-        response = self._scope.query(f"{self._prefix}:VDIV?")
+        response = self._scope.query(self._cmd("get_voltage_div", ch=self._channel))
         # Response may include echo like "C1:VDIV 1.0E+00V" or just "1.0E+00V"
         # Remove the echo prefix if present
         if ":" in response:
@@ -120,7 +127,7 @@ class Channel:
         """
         if volts_per_div <= 0:
             raise exceptions.InvalidParameterError(f"Voltage scale must be positive: {volts_per_div}")
-        self._scope.write(f"{self._prefix}:VDIV {volts_per_div}")
+        self._scope.write(self._cmd("set_voltage_div", ch=self._channel, vdiv=volts_per_div))
         logger.info(f"Channel {self._channel} scale set to {volts_per_div} V/div")
 
     def set_scale(self, volts_per_div: float) -> None:
@@ -138,7 +145,7 @@ class Channel:
         Returns:
             Offset voltage in volts
         """
-        response = self._scope.query(f"{self._prefix}:OFST?")
+        response = self._scope.query(self._cmd("get_voltage_offset", ch=self._channel))
         # Response may include echo like "C1:OFST 1.0E+00V"
         if ":" in response:
             response = response.split(":", 1)[1]
@@ -154,7 +161,7 @@ class Channel:
         Args:
             offset: Offset voltage in volts
         """
-        self._scope.write(f"{self._prefix}:OFST {offset}")
+        self._scope.write(self._cmd("set_voltage_offset", ch=self._channel, offset=offset))
         logger.info(f"Channel {self._channel} offset set to {offset} V")
 
     @property
@@ -164,13 +171,18 @@ class Channel:
         Returns:
             Probe ratio (e.g., 1.0 for 1X, 10.0 for 10X)
         """
-        response = self._scope.query(f"{self._prefix}:ATTN?")
+        # 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:
@@ -183,7 +195,14 @@ class Channel:
         """
         if ratio <= 0:
             raise exceptions.InvalidParameterError(f"Probe ratio must be positive: {ratio}")
-        self._scope.write(f"{self._prefix}:ATTN {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
@@ -193,8 +212,23 @@ class Channel:
         Returns:
             Bandwidth limit: 'ON', 'OFF', or frequency limit
         """
-        response = self._scope.query(f"{self._prefix}:BWL?")
-        return response.upper().strip()
+        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 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
 
     @bandwidth_limit.setter
     def bandwidth_limit(self, limit: BandwidthLimitType) -> None:
@@ -206,10 +240,26 @@ class Channel:
         limit = limit.upper()
         if limit not in ["ON", "OFF", "FULL"]:
             raise exceptions.InvalidParameterError(f"Invalid bandwidth limit: {limit}. Must be ON, OFF, or FULL.")
-        # Convert FULL to OFF for compatibility
-        if limit == "FULL":
-            limit = "OFF"
-        self._scope.write(f"{self._prefix}:BWL {limit}")
+        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))
         logger.info(f"Channel {self._channel} bandwidth limit set to {limit}")
 
     @property
@@ -219,7 +269,9 @@ class Channel:
         Returns:
             Unit string (typically 'V' for volts)
         """
-        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
@@ -229,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:
@@ -241,7 +295,7 @@ class Channel:
         # For per-channel auto-scale, we might need to use different commands
         # This is a basic implementation that may need adjustment for SD824x
         logger.info(f"Auto-scaling channel {self._channel}")
-        self._scope.write("ASET")
+        self._scope.write(self._cmd("auto_setup"))
 
     def get_configuration(self) -> dict:
         """Get all channel configuration parameters.
@@ -249,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/base.py

@@ -1,5 +1,6 @@
 """Abstract base class for oscilloscope connections."""
 
+import threading
 from abc import ABC, abstractmethod
 from typing import Optional, Union
 
@@ -19,6 +20,9 @@ class BaseConnection(ABC):
         self.port = port
         self.timeout = timeout
         self._connected = False
+        # Reentrant so query() can hold it across its own write()/read() calls.
+        # Callers doing compound exchanges (write + read_raw) must hold it too.
+        self.lock = threading.RLock()
 
     @abstractmethod
     def connect(self) -> None:

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,4 +1,5 @@
-"""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
 
@@ -7,11 +8,15 @@ 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}"
+_PERSONALITIES = {
+    "siglent": siglent,
+    "tektronix": tektronix,
+    "lecroy": lecroy,
+}
 
 
 class MockConnection(BaseConnection):
@@ -49,24 +54,56 @@ 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
+        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}
         self._waveform_payloads: Dict[int, bytes] = {ch: (waveform_payloads.get(ch, bytes([0, 25, 50, 75])) if waveform_payloads else bytes([0, 25, 50, 75])) for ch in channels}
+        self._channel_coupling: Dict[int, str] = {ch: "D1M" for ch in channels}
 
         self.sample_rate = sample_rate
         self.timebase = timebase
-        self.trigger_mode = "STOP"
         self.trigger_type = "EDGE"
         self.trigger_source = "C1"
+        if self.scope_dialect == "modern":
+            # Initial wire tokens must be modern vocabulary (guide p.482, p.494)
+            self.trigger_mode = "AUTO"
+            self.trigger_slope = "RISing"
+        else:
+            self.trigger_mode = "STOP"
+            self.trigger_slope = "POS"
+        self.trigger_coupling = "DC"
         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] = []
@@ -311,45 +348,18 @@ class MockConnection(BaseConnection):
                     self.awg_channels[ch]["enabled"] = enabled
                 return
 
-        # Oscilloscope 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 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 command.upper() == "ARM":
-            # Simulate an acquisition that will eventually stop when no custom sequence is provided
-            if len(self.trigger_status) <= 1:
-                self.trigger_status = ["Run", "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:
@@ -587,59 +597,31 @@ class MockConnection(BaseConnection):
                     return "CV"
                 return "CV"
 
-        if upper in {":TRIG:STAT?", "TRIG:STAT?"}:
-            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
+        personality = _PERSONALITIES.get(self.scope_vendor, siglent)
+        response = personality.handle_query(self, command)
+        if response is not None:
+            return response
 
-        if upper == "TRIG_SELECT?":
-            return f"{self.trigger_type},SR,{self.trigger_source}"
+        if self.psu_mode or self.awg_mode or self.daq_mode:
+            return ""
 
-        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 f"C{channel}:VDIV {_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 f"C{channel}:OFST {_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+):TRLV\?", command, re.IGNORECASE):
-            channel = int(match.group(1))
-            return f"C{channel}:TRLV {_format_scientific(self.trigger_level.get(channel, 0.0), 'V')}"
-
-        if upper == "TDIV?":
-            return f"TDIV {_format_scientific(self.timebase, 'S')}"
-
-        if upper == "SARA?":
-            return f"SARA {_format_scientific(self.sample_rate, 'SA/S')}"
-
-        return ""
+        # Real scopes produce no response at all for unknown or wrong-dialect
+        # queries - the caller's read times out. Model that honestly.
+        raise exceptions.TimeoutError(f"MockConnection ({self.scope_dialect}) has no response for query: {command!r}")
 
     def query_many(self, commands: Iterable[str]) -> List[str]:
         """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."""
-        length = len(payload)
-        length_str = str(length).encode()
-        header = b"DESC,#" + str(len(length_str)).encode() + length_str
-        return header + payload
-
     def read_raw(self, size: Optional[int] = None) -> bytes:
-        """Return deterministic raw waveform data."""
+        """Return deterministic raw waveform data (or a mock screenshot BMP after SCDP?)."""
         if not self._connected:
             raise exceptions.ConnectionError(f"Not connected to oscilloscope at {self.host}:{self.port}")
 
-        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)
+        if self.writes and self.writes[-1].upper() == "SCDP?":
+            # Bare IEEE 488.2 block (no "DESC," prefix), matching how a real
+            # scope's SCDP? reply is parsed in screen_capture.py.
+            return _build_ieee_block(MOCK_SCREENSHOT_BMP)
+
+        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")