SCPI-Instrument-Control 1.0.1__py3-none-any.whl → 1.1.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__ = "1.1.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/connection/mock.py

@@ -45,6 +45,10 @@ class MockConnection(BaseConnection):
         awg_mode: bool = False,
         awg_idn: str = "Siglent Technologies,SDG1032X,SDG1XXXXX,2.01.01.37R1",
         awg_channels: Optional[Dict[int, Dict[str, any]]] = None,
+        # Data acquisition (DAQ) parameters
+        daq_mode: bool = False,
+        daq_idn: str = "Keysight Technologies,34970A,MY12345678,A.01.02",
+        daq_readings: str = "1.234,2.345,3.456",
     ):
         super().__init__(host, port, timeout)
         channels = channel_states.keys() if channel_states else range(1, 3)
@@ -112,6 +116,12 @@ class MockConnection(BaseConnection):
             },
         }
 
+        # Data acquisition (DAQ) mode
+        self.daq_mode = daq_mode
+        self.daq_idn = daq_idn
+        self.daq_readings = daq_readings
+        self.daq_scan_list = []
+
     def connect(self) -> None:
         """Mark the connection as established."""
         self._connected = True
@@ -365,13 +375,35 @@ class MockConnection(BaseConnection):
         upper = command.upper()
 
         if upper == "*IDN?":
-            if self.awg_mode:
+            if self.daq_mode:
+                return self.daq_idn
+            elif self.awg_mode:
                 return self.awg_idn
             elif self.psu_mode:
                 return self.psu_idn
             else:
                 return self.idn
 
+        # Data acquisition (DAQ) queries
+        if self.daq_mode:
+            # Return configured readings for any measurement/read/fetch query
+            if any(kw in upper for kw in ["READ?", "FETC?", "MEAS:", "R?"]):
+                return self.daq_readings
+
+            # Scan list query
+            if "ROUT:SCAN?" in upper:
+                if self.daq_scan_list:
+                    return f"(@{','.join(str(ch) for ch in self.daq_scan_list)})"
+                return "(@)"
+
+            # Data points query
+            if "DATA:POIN?" in upper:
+                return str(len(self.daq_readings.split(",")))
+
+            # Error query
+            if "SYST:ERR?" in upper:
+                return '+0,"No error"'
+
         # Function generator (AWG) queries
         if self.awg_mode:
             # Function queries: C1:BSWV? WVTP (Siglent) or SOUR1:FUNC? (generic)

scpi_control/daq_models.py

@@ -0,0 +1,316 @@
+"""Model capability definitions for SCPI-controlled Data Acquisition systems.
+
+Supports generic SCPI-99 DAQ/Data Loggers and Keysight 34970A/DAQ970A series models.
+"""
+
+import logging
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class MeasurementFunction(Enum):
+    """Supported measurement functions for DAQ channels."""
+
+    VOLTAGE_DC = "VOLT:DC"
+    VOLTAGE_AC = "VOLT:AC"
+    CURRENT_DC = "CURR:DC"
+    CURRENT_AC = "CURR:AC"
+    RESISTANCE_2W = "RES"  # 2-wire resistance
+    RESISTANCE_4W = "FRES"  # 4-wire (Fresistance)
+    FREQUENCY = "FREQ"
+    PERIOD = "PER"
+    TEMPERATURE = "TEMP"  # Thermocouple, RTD, thermistor
+    CONTINUITY = "CONT"
+    DIODE = "DIOD"
+    DIGITAL_INPUT = "DIG:INP"
+    DIGITAL_OUTPUT = "DIG:OUTP"
+    TOTALIZER = "TOT"  # Counter/totalizer
+
+
+@dataclass
+class ModuleSpec:
+    """Specification for a DAQ plug-in module/card."""
+
+    slot: int  # Slot number (1, 2, 3, etc.)
+    module_type: str  # Module type identifier (e.g., "34901A", "DAQM901A")
+    num_channels: int  # Number of channels on this module
+    channel_start: int  # Starting channel number (e.g., 101 for slot 1)
+    supported_functions: List[MeasurementFunction]  # Supported measurement types
+    max_voltage: float = 300.0  # Maximum input voltage
+    max_current: float = 1.0  # Maximum input current (if applicable)
+    has_switching: bool = True  # Multiplexer/switching capability
+    description: str = ""  # Human-readable description
+
+    def __str__(self) -> str:
+        """String representation of module spec."""
+        return f"Slot {self.slot}: {self.module_type} ({self.num_channels}ch, {self.channel_start}-{self.channel_start + self.num_channels - 1})"
+
+    def get_channel_list(self) -> List[int]:
+        """Get list of all channel numbers for this module."""
+        return list(range(self.channel_start, self.channel_start + self.num_channels))
+
+
+@dataclass
+class DAQCapability:
+    """Defines capabilities and features for a specific DAQ model.
+
+    This dataclass contains all model-specific information including hardware
+    specifications and supported features.
+    """
+
+    model_name: str  # Full model name (e.g., "34970A", "DAQ970A")
+    manufacturer: str  # Manufacturer name (e.g., "Keysight", "Agilent")
+    num_slots: int  # Number of module slots
+    modules: List[ModuleSpec] = field(default_factory=list)  # Installed modules
+    has_internal_dmm: bool = True  # Built-in digital multimeter
+    dmm_resolution: float = 6.5  # DMM resolution in digits
+    max_sample_rate: float = 250.0  # Maximum scan rate (channels/second)
+    memory_readings: int = 50000  # Reading memory capacity
+    has_timestamp: bool = True  # Timestamp capability
+    has_alarm: bool = True  # Alarm/limit checking
+    has_math: bool = True  # Math functions (mx+b scaling)
+    scpi_variant: str = "generic"  # SCPI command variant
+
+    def __str__(self) -> str:
+        """String representation of DAQ capability."""
+        return f"{self.manufacturer} {self.model_name} ({self.num_slots} slots, {self.scpi_variant})"
+
+    @property
+    def total_channels(self) -> int:
+        """Get total number of channels across all modules."""
+        return sum(m.num_channels for m in self.modules)
+
+    def get_all_channels(self) -> List[int]:
+        """Get list of all channel numbers across all modules."""
+        channels = []
+        for module in self.modules:
+            channels.extend(module.get_channel_list())
+        return sorted(channels)
+
+
+# Common module types
+MULTIPLEXER_20CH = lambda slot: ModuleSpec(
+    slot=slot,
+    module_type="34901A",
+    num_channels=20,
+    channel_start=slot * 100 + 1,
+    supported_functions=[
+        MeasurementFunction.VOLTAGE_DC,
+        MeasurementFunction.VOLTAGE_AC,
+        MeasurementFunction.CURRENT_DC,
+        MeasurementFunction.CURRENT_AC,
+        MeasurementFunction.RESISTANCE_2W,
+        MeasurementFunction.RESISTANCE_4W,
+        MeasurementFunction.FREQUENCY,
+        MeasurementFunction.PERIOD,
+        MeasurementFunction.TEMPERATURE,
+    ],
+    max_voltage=300.0,
+    description="20-Channel Multiplexer (2/4-wire)",
+)
+
+MULTIPLEXER_40CH = lambda slot: ModuleSpec(
+    slot=slot,
+    module_type="34902A",
+    num_channels=16,
+    channel_start=slot * 100 + 1,
+    supported_functions=[
+        MeasurementFunction.VOLTAGE_DC,
+        MeasurementFunction.VOLTAGE_AC,
+        MeasurementFunction.RESISTANCE_2W,
+        MeasurementFunction.FREQUENCY,
+        MeasurementFunction.PERIOD,
+        MeasurementFunction.TEMPERATURE,
+    ],
+    max_voltage=300.0,
+    description="16-Channel Multiplexer (2-wire only)",
+)
+
+DIGITAL_IO_MODULE = lambda slot: ModuleSpec(
+    slot=slot,
+    module_type="34903A",
+    num_channels=20,
+    channel_start=slot * 100 + 1,
+    supported_functions=[
+        MeasurementFunction.DIGITAL_INPUT,
+        MeasurementFunction.DIGITAL_OUTPUT,
+    ],
+    has_switching=True,
+    description="20-Channel Actuator/GP Switch",
+)
+
+
+# DAQ Model Registry - Add new models here
+DAQ_MODEL_REGISTRY = {
+    # Keysight/Agilent 34970A (classic model)
+    "34970A": DAQCapability(
+        model_name="34970A",
+        manufacturer="Keysight",
+        num_slots=3,
+        modules=[MULTIPLEXER_20CH(1)],  # Default config - can be updated after connection
+        has_internal_dmm=True,
+        dmm_resolution=6.5,
+        max_sample_rate=250.0,
+        memory_readings=50000,
+        has_timestamp=True,
+        has_alarm=True,
+        has_math=True,
+        scpi_variant="keysight_daq",
+    ),
+    # Keysight 34972A (USB enabled version)
+    "34972A": DAQCapability(
+        model_name="34972A",
+        manufacturer="Keysight",
+        num_slots=3,
+        modules=[MULTIPLEXER_20CH(1)],
+        has_internal_dmm=True,
+        dmm_resolution=6.5,
+        max_sample_rate=250.0,
+        memory_readings=50000,
+        has_timestamp=True,
+        has_alarm=True,
+        has_math=True,
+        scpi_variant="keysight_daq",
+    ),
+    # Keysight DAQ970A (modern replacement)
+    "DAQ970A": DAQCapability(
+        model_name="DAQ970A",
+        manufacturer="Keysight",
+        num_slots=3,
+        modules=[MULTIPLEXER_20CH(1)],
+        has_internal_dmm=True,
+        dmm_resolution=6.5,
+        max_sample_rate=450.0,  # Faster scanning
+        memory_readings=500000,  # More memory
+        has_timestamp=True,
+        has_alarm=True,
+        has_math=True,
+        scpi_variant="keysight_daq",
+    ),
+    # Keysight DAQ973A (no internal DMM)
+    "DAQ973A": DAQCapability(
+        model_name="DAQ973A",
+        manufacturer="Keysight",
+        num_slots=3,
+        modules=[],
+        has_internal_dmm=False,
+        dmm_resolution=0,
+        max_sample_rate=450.0,
+        memory_readings=500000,
+        has_timestamp=True,
+        has_alarm=True,
+        has_math=False,
+        scpi_variant="keysight_daq",
+    ),
+}
+
+
+def detect_daq_from_idn(idn_string: str) -> DAQCapability:
+    """Detect DAQ model and return its capability profile.
+
+    Args:
+        idn_string: The response from *IDN? command
+                   Format: "Manufacturer,Model,Serial,Firmware"
+                   Example: "Keysight Technologies,34970A,MY12345678,A.01.02"
+
+    Returns:
+        DAQCapability object for the detected model
+
+    Note:
+        Unknown models will receive a generic SCPI capability profile
+        to enable basic control functionality.
+    """
+    parts = idn_string.split(",")
+    if len(parts) < 2:
+        logger.warning(f"Invalid *IDN? response format: {idn_string}")
+        return create_generic_daq_capability(idn_string)
+
+    manufacturer = parts[0].strip()
+    model_from_idn = parts[1].strip()
+    logger.info(f"Detecting DAQ model from IDN: {manufacturer}, {model_from_idn}")
+
+    # Try exact match first
+    if model_from_idn in DAQ_MODEL_REGISTRY:
+        logger.info(f"Exact match found: {model_from_idn}")
+        return DAQ_MODEL_REGISTRY[model_from_idn]
+
+    # Try fuzzy matching
+    normalized_model = re.sub(r"[\s\-_]", "", model_from_idn).upper()
+
+    for registered_model, capability in DAQ_MODEL_REGISTRY.items():
+        normalized_registered = re.sub(r"[\s\-_]", "", registered_model).upper()
+        if normalized_model == normalized_registered:
+            logger.info(f"Fuzzy match found: {model_from_idn} -> {registered_model}")
+            return capability
+
+    # Try partial matching for Keysight/Agilent models
+    if any(mfr in manufacturer for mfr in ["Keysight", "Agilent", "HP"]):
+        for registered_model, capability in DAQ_MODEL_REGISTRY.items():
+            if registered_model in model_from_idn:
+                logger.info(f"Partial match found: {model_from_idn} -> {registered_model}")
+                return capability
+
+    # Model not found - create generic fallback
+    logger.warning(f"Model '{model_from_idn}' not in registry, using generic SCPI profile")
+    return create_generic_daq_capability(idn_string)
+
+
+def create_generic_daq_capability(idn_string: str) -> DAQCapability:
+    """Create generic SCPI capability for unknown DAQ.
+
+    Args:
+        idn_string: The *IDN? response string
+
+    Returns:
+        Generic DAQCapability with conservative defaults
+    """
+    parts = idn_string.split(",")
+    manufacturer = parts[0].strip() if len(parts) > 0 else "Unknown"
+    model = parts[1].strip() if len(parts) > 1 else "Generic DAQ"
+
+    logger.info(f"Creating generic DAQ capability for {manufacturer} {model}")
+
+    generic_capability = DAQCapability(
+        model_name=model,
+        manufacturer=manufacturer,
+        num_slots=1,
+        modules=[
+            ModuleSpec(
+                slot=1,
+                module_type="Generic",
+                num_channels=20,
+                channel_start=101,
+                supported_functions=[
+                    MeasurementFunction.VOLTAGE_DC,
+                    MeasurementFunction.VOLTAGE_AC,
+                    MeasurementFunction.RESISTANCE_2W,
+                ],
+                description="Generic Input Module",
+            )
+        ],
+        has_internal_dmm=True,
+        dmm_resolution=5.5,
+        max_sample_rate=100.0,
+        memory_readings=10000,
+        has_timestamp=True,
+        has_alarm=False,
+        has_math=False,
+        scpi_variant="generic",
+    )
+
+    logger.info(f"Created generic capability: {generic_capability}")
+    return generic_capability
+
+
+def list_supported_models() -> List[str]:
+    """Get list of all explicitly supported DAQ model names."""
+    return sorted(DAQ_MODEL_REGISTRY.keys())
+
+
+def get_models_by_manufacturer(manufacturer: str) -> List[DAQCapability]:
+    """Get all models from a specific manufacturer."""
+    return [cap for cap in DAQ_MODEL_REGISTRY.values() if cap.manufacturer.lower() == manufacturer.lower()]

scpi_control/daq_scpi_commands.py

@@ -0,0 +1,227 @@
+"""SCPI command sets for Data Acquisition system control.
+
+Provides generic SCPI-99 commands for DAQ systems,
+with Keysight-specific command overrides for 34970A/DAQ970A series.
+"""
+
+import logging
+from typing import Dict, List, Union
+
+logger = logging.getLogger(__name__)
+
+
+def format_channel_list(channels: Union[int, List[int], str]) -> str:
+    """Format channel list for SCPI commands.
+
+    Args:
+        channels: Channel number(s) - can be:
+                 - Single int: 101
+                 - List of ints: [101, 102, 103]
+                 - String (already formatted): "(@101:103)"
+
+    Returns:
+        Formatted channel string like "(@101,102,103)" or "(@101:110)"
+
+    Examples:
+        >>> format_channel_list(101)
+        '(@101)'
+        >>> format_channel_list([101, 102, 103])
+        '(@101,102,103)'
+        >>> format_channel_list("(@101:110)")
+        '(@101:110)'
+    """
+    if isinstance(channels, str):
+        # Already formatted
+        if channels.startswith("(@"):
+            return channels
+        return f"(@{channels})"
+    elif isinstance(channels, int):
+        return f"(@{channels})"
+    elif isinstance(channels, (list, tuple)):
+        return f"(@{','.join(str(ch) for ch in channels)})"
+    else:
+        raise ValueError(f"Invalid channel format: {channels}")
+
+
+class DAQSCPICommandSet:
+    """SCPI command abstraction for Data Acquisition systems.
+
+    Supports generic SCPI-99 commands with model-specific overrides for
+    known manufacturers (e.g., Keysight 34970A/DAQ970A series).
+    """
+
+    # Generic SCPI-99 commands (standard compliant)
+    GENERIC_COMMANDS: Dict[str, str] = {
+        # System commands (IEEE 488.2)
+        "identify": "*IDN?",
+        "reset": "*RST",
+        "clear_status": "*CLS",
+        "get_error": "SYST:ERR?",
+        "operation_complete": "*OPC?",
+        # Configuration commands
+        "configure_voltage_dc": "CONF:VOLT:DC {range},{resolution},{channels}",
+        "configure_voltage_ac": "CONF:VOLT:AC {range},{resolution},{channels}",
+        "configure_current_dc": "CONF:CURR:DC {range},{resolution},{channels}",
+        "configure_current_ac": "CONF:CURR:AC {range},{resolution},{channels}",
+        "configure_resistance_2w": "CONF:RES {range},{resolution},{channels}",
+        "configure_resistance_4w": "CONF:FRES {range},{resolution},{channels}",
+        "configure_frequency": "CONF:FREQ {range},{resolution},{channels}",
+        "configure_period": "CONF:PER {range},{resolution},{channels}",
+        "configure_temperature": "CONF:TEMP {sensor_type},{channels}",
+        # Scan list management
+        "set_scan_list": "ROUT:SCAN {channels}",
+        "get_scan_list": "ROUT:SCAN?",
+        "clear_scan_list": "ROUT:SCAN (@)",
+        # Channel delay
+        "set_channel_delay": "ROUT:CHAN:DEL {delay},{channels}",
+        "get_channel_delay": "ROUT:CHAN:DEL? {channels}",
+        # Trigger control
+        "set_trigger_source": "TRIG:SOUR {source}",
+        "get_trigger_source": "TRIG:SOUR?",
+        "set_trigger_count": "TRIG:COUN {count}",
+        "get_trigger_count": "TRIG:COUN?",
+        "set_trigger_delay": "TRIG:DEL {delay}",
+        "get_trigger_delay": "TRIG:DEL?",
+        "set_trigger_timer": "TRIG:TIM {interval}",
+        "get_trigger_timer": "TRIG:TIM?",
+        # Acquisition control
+        "initiate": "INIT",
+        "abort": "ABOR",
+        "trigger": "*TRG",
+        # Data retrieval
+        "read": "READ?",
+        "fetch": "FETC?",
+        "read_remove": "R? {max_readings}",
+        "get_data_points": "DATA:POIN?",
+        "clear_data": "DATA:DEL NVMEM",
+        # Measurement commands (immediate)
+        "measure_voltage_dc": "MEAS:VOLT:DC? {range},{resolution},{channels}",
+        "measure_voltage_ac": "MEAS:VOLT:AC? {range},{resolution},{channels}",
+        "measure_current_dc": "MEAS:CURR:DC? {range},{resolution},{channels}",
+        "measure_current_ac": "MEAS:CURR:AC? {range},{resolution},{channels}",
+        "measure_resistance_2w": "MEAS:RES? {range},{resolution},{channels}",
+        "measure_resistance_4w": "MEAS:FRES? {range},{resolution},{channels}",
+        "measure_frequency": "MEAS:FREQ? {range},{resolution},{channels}",
+        "measure_temperature": "MEAS:TEMP? {sensor_type},{channels}",
+        # Status
+        "get_scan_state": "ROUT:SCAN:STAT?",
+    }
+
+    # Keysight DAQ series command overrides (34970A, DAQ970A, etc.)
+    KEYSIGHT_DAQ_OVERRIDES: Dict[str, str] = {
+        # Configuration with AUTO range/resolution support
+        "configure_voltage_dc": "CONF:VOLT:DC {range},{resolution},{channels}",
+        "configure_voltage_ac": "CONF:VOLT:AC {range},{resolution},{channels}",
+        "configure_current_dc": "CONF:CURR:DC {range},{resolution},{channels}",
+        "configure_current_ac": "CONF:CURR:AC {range},{resolution},{channels}",
+        "configure_resistance_2w": "CONF:RES {range},{resolution},{channels}",
+        "configure_resistance_4w": "CONF:FRES {range},{resolution},{channels}",
+        # Temperature with sensor type
+        "configure_temperature_tc": "CONF:TEMP TC,{tc_type},{channels}",
+        "configure_temperature_rtd": "CONF:TEMP RTD,{rtd_type},{channels}",
+        "configure_temperature_therm": "CONF:TEMP THER,{therm_type},{channels}",
+        # Sample count per trigger
+        "set_sample_count": "SAMP:COUN {count}",
+        "get_sample_count": "SAMP:COUN?",
+        # Advanced trigger modes
+        "set_trigger_source_immediate": "TRIG:SOUR IMM",
+        "set_trigger_source_timer": "TRIG:SOUR TIM",
+        "set_trigger_source_bus": "TRIG:SOUR BUS",
+        "set_trigger_source_external": "TRIG:SOUR EXT",
+        # Data format
+        "set_data_format": "FORM:READ:ALAR {state}",  # Include alarm info
+        "set_data_timestamp": "FORM:READ:TIME {state}",  # Include timestamp
+        "set_data_channel": "FORM:READ:CHAN {state}",  # Include channel number
+        "set_data_unit": "FORM:READ:UNIT {state}",  # Include units
+        # Alarm/limit configuration
+        "set_alarm_high": "CALC:LIM:UPP {limit},{channels}",
+        "get_alarm_high": "CALC:LIM:UPP? {channels}",
+        "set_alarm_low": "CALC:LIM:LOW {limit},{channels}",
+        "get_alarm_low": "CALC:LIM:LOW? {channels}",
+        "set_alarm_enable": "CALC:LIM:STAT {state},{channels}",
+        "get_alarm_enable": "CALC:LIM:STAT? {channels}",
+        # Scaling (mx+b)
+        "set_scaling_gain": "CALC:SCAL:GAIN {gain},{channels}",
+        "get_scaling_gain": "CALC:SCAL:GAIN? {channels}",
+        "set_scaling_offset": "CALC:SCAL:OFFS {offset},{channels}",
+        "get_scaling_offset": "CALC:SCAL:OFFS? {channels}",
+        "set_scaling_enable": "CALC:SCAL:STAT {state},{channels}",
+        "get_scaling_enable": "CALC:SCAL:STAT? {channels}",
+        # DMM digitize mode (fast acquisition)
+        "configure_digitize": "ACQ:VOLT:DC {range},{channels}",
+        "set_digitize_rate": "ACQ:SRAT {rate}",
+        "get_digitize_rate": "ACQ:SRAT?",
+        # Monitor a single channel continuously
+        "set_monitor_channel": "ROUT:MON {channel}",
+        "get_monitor_channel": "ROUT:MON?",
+        "set_monitor_enable": "ROUT:MON:STAT {state}",
+        "get_monitor_enable": "ROUT:MON:STAT?",
+        "read_monitor": "ROUT:MON:DATA?",
+        # Module identification
+        "get_module_info": "SYST:CTYP? {slot}",
+    }
+
+    def __init__(self, variant: str = "generic"):
+        """Initialize SCPI command set with variant.
+
+        Args:
+            variant: Command variant to use ("generic", "keysight_daq")
+        """
+        self.variant = variant
+        logger.info(f"Initialized DAQ SCPI command set with variant: {variant}")
+
+    def get_command(self, command_name: str, **kwargs) -> str:
+        """Get SCPI command string with parameter substitution.
+
+        Uses model-specific commands if available, falls back to generic.
+
+        Args:
+            command_name: Name of the command (e.g., "configure_voltage_dc")
+            **kwargs: Parameters for command template substitution
+
+        Returns:
+            Formatted SCPI command string
+
+        Raises:
+            KeyError: If command_name is not found
+            ValueError: If required parameters are missing
+
+        Example:
+            >>> cmd_set = DAQSCPICommandSet("keysight_daq")
+            >>> cmd = cmd_set.get_command("configure_voltage_dc",
+            ...                           range="AUTO", resolution="AUTO",
+            ...                           channels="(@101:103)")
+            >>> print(cmd)
+            'CONF:VOLT:DC AUTO,AUTO,(@101:103)'
+        """
+        # Try model-specific commands first
+        if self.variant == "keysight_daq":
+            if command_name in self.KEYSIGHT_DAQ_OVERRIDES:
+                template = self.KEYSIGHT_DAQ_OVERRIDES[command_name]
+                try:
+                    return template.format(**kwargs)
+                except KeyError as e:
+                    raise ValueError(f"Missing required parameter for command '{command_name}': {e}")
+
+        # Fall back to generic SCPI commands
+        if command_name in self.GENERIC_COMMANDS:
+            template = self.GENERIC_COMMANDS[command_name]
+            try:
+                return template.format(**kwargs)
+            except KeyError as e:
+                raise ValueError(f"Missing required parameter for command '{command_name}': {e}")
+
+        raise KeyError(f"Unknown command: '{command_name}' for variant '{self.variant}'")
+
+    def supports_command(self, command_name: str) -> bool:
+        """Check if a command is supported by this variant."""
+        if self.variant == "keysight_daq" and command_name in self.KEYSIGHT_DAQ_OVERRIDES:
+            return True
+        return command_name in self.GENERIC_COMMANDS
+
+    def list_commands(self) -> list:
+        """Get list of all available command names for this variant."""
+        commands = set(self.GENERIC_COMMANDS.keys())
+        if self.variant == "keysight_daq":
+            commands.update(self.KEYSIGHT_DAQ_OVERRIDES.keys())
+        return sorted(commands)