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

scpi_control/__init__.py

@@ -7,6 +7,7 @@ Supported equipment:
 - Oscilloscopes (Siglent SDS series and SCPI-compatible models)
 - Function Generators / AWGs (Siglent SDG series and SCPI-compatible models)
 - Power Supplies (Siglent SPD series and SCPI-compatible models)
+- Data Acquisition / Data Loggers (Keysight 34970A/DAQ970A and SCPI-compatible models)
 
 For high-level automation and data collection, see the automation module:
     from scpi_control.automation import DataCollector, TriggerWaitCollector
@@ -17,11 +18,14 @@ For power supply control:
 For function generator control:
     from scpi_control import FunctionGenerator
 
+For data acquisition / data logging:
+    from scpi_control import DataLogger
+
 For automated test report generation:
     from scpi_control.report_generator import ReportGenerator
 """
 
-__version__ = "1.0.1"
+__version__ = "2.0.0"
 
 from scpi_control.exceptions import CommandError, SiglentConnectionError, SiglentError, SiglentTimeoutError
 from scpi_control.oscilloscope import Oscilloscope
@@ -33,6 +37,9 @@ from scpi_control.psu_data_logger import PSUDataLogger, TimedPSULogger
 # Function generator support (new in v0.6.0, stable in v1.0.0)
 from scpi_control.function_generator import FunctionGenerator
 
+# Data acquisition / Data logger support (new in v1.1.0)
+from scpi_control.data_logger import DataLogger
+
 __all__ = [
     # Core features
     "Oscilloscope",
@@ -46,4 +53,6 @@ __all__ = [
     "TimedPSULogger",
     # Function generator features
     "FunctionGenerator",
+    # Data acquisition features
+    "DataLogger",
 ]

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: