SCPI-Instrument-Control 1.1.0__py3-none-any.whl → 2.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__ = "2.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,7 @@ 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
 
 if TYPE_CHECKING:
     from scpi_control.oscilloscope import Oscilloscope
@@ -35,6 +36,13 @@ class Channel:
         if not 1 <= channel_number <= 4:
             raise exceptions.InvalidParameterError(f"Invalid channel number: {channel_number}. Must be 1-4.")
 
+    @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:
         """Get channel display state.
@@ -42,7 +50,7 @@ class Channel:
         Returns:
             True if channel is displayed, False otherwise
         """
-        response = self._scope.query(f"{self._prefix}:TRA?")
+        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()
@@ -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,7 +171,7 @@ class Channel:
         Returns:
             Probe ratio (e.g., 1.0 for 1X, 10.0 for 10X)
         """
-        response = self._scope.query(f"{self._prefix}:ATTN?")
+        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]
@@ -183,7 +190,7 @@ class Channel:
         """
         if ratio <= 0:
             raise exceptions.InvalidParameterError(f"Probe ratio must be positive: {ratio}")
-        self._scope.write(f"{self._prefix}:ATTN {ratio}")
+        self._scope.write(self._cmd("set_probe_ratio", ch=self._channel, ratio=ratio))
         logger.info(f"Channel {self._channel} probe ratio set to {ratio}X")
 
     @property
@@ -193,8 +200,11 @@ class Channel:
         Returns:
             Bandwidth limit: 'ON', 'OFF', or frequency limit
         """
-        response = self._scope.query(f"{self._prefix}:BWL?")
-        return response.upper().strip()
+        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
+            return "OFF" if response == "FULL" else "ON"
+        return response
 
     @bandwidth_limit.setter
     def bandwidth_limit(self, limit: BandwidthLimitType) -> None:
@@ -206,10 +216,11 @@ 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"
+        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,6 +230,7 @@ class Channel:
         Returns:
             Unit string (typically 'V' for volts)
         """
+        # legacy-only command; not routed
         response = self._scope.query(f"{self._prefix}:UNIT?")
         return response.strip()
 
@@ -241,7 +253,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.

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.py

@@ -3,10 +3,11 @@
 from __future__ import annotations
 
 import re
-from typing import Dict, Iterable, List, Optional, Union
+from typing import Dict, Iterable, List, Optional, Tuple, Union
 
 from scpi_control import exceptions
 from scpi_control.connection.base import BaseConnection
+from scpi_control.models import detect_model_from_idn
 
 
 def _format_scientific(value: float, unit: str) -> str:
@@ -14,6 +15,44 @@ def _format_scientific(value: float, unit: str) -> str:
     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", "%"),
+}
+
+
 class MockConnection(BaseConnection):
     """Mock connection that returns deterministic SCPI responses.
 
@@ -54,16 +93,26 @@ class MockConnection(BaseConnection):
         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
         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"]
 
@@ -312,6 +361,56 @@ class MockConnection(BaseConnection):
                 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:
@@ -331,6 +430,8 @@ class MockConnection(BaseConnection):
         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 "):
@@ -338,10 +439,15 @@ class MockConnection(BaseConnection):
             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
+            # 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 = ["Run", "Stop"]
+                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))
@@ -587,42 +693,95 @@ 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
-
-        if upper == "TRIG_SELECT?":
-            return f"{self.trigger_type},SR,{self.trigger_source}"
-
-        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 ""
+        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}"
+
+        if self.psu_mode or self.awg_mode or self.daq_mode:
+            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."""
@@ -630,16 +789,18 @@ class MockConnection(BaseConnection):
 
     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
+        return b"DESC," + _build_ieee_block(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}")
 
+        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)
+
         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)