SCPI-Instrument-Control 1.0.1__tar.gz → 1.1.0__tar.gz

{scpi_instrument_control-1.0.1/SCPI_Instrument_Control.egg-info → scpi_instrument_control-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SCPI-Instrument-Control
-Version: 1.0.1
+Version: 1.1.0
 Summary: Universal Python library for controlling SCPI-compatible test equipment via Ethernet/LAN. Supports oscilloscopes (Siglent SDS series, generic SCPI scopes), function generators/AWGs (Siglent SDG series, generic SCPI AWGs), and power supplies (Siglent SPD series, generic SCPI PSUs). Features include waveform capture, measurements, FFT analysis, PyQt6 GUI, automated report generation with AI analysis, and comprehensive SCPI command abstraction.
 Author: Robin Mumm
 Maintainer: little-did-I-know

{scpi_instrument_control-1.0.1 → scpi_instrument_control-1.1.0/SCPI_Instrument_Control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SCPI-Instrument-Control
-Version: 1.0.1
+Version: 1.1.0
 Summary: Universal Python library for controlling SCPI-compatible test equipment via Ethernet/LAN. Supports oscilloscopes (Siglent SDS series, generic SCPI scopes), function generators/AWGs (Siglent SDG series, generic SCPI AWGs), and power supplies (Siglent SPD series, generic SCPI PSUs). Features include waveform capture, measurements, FFT analysis, PyQt6 GUI, automated report generation with AI analysis, and comprehensive SCPI command abstraction.
 Author: Robin Mumm
 Maintainer: little-did-I-know

{scpi_instrument_control-1.0.1 → scpi_instrument_control-1.1.0}/SCPI_Instrument_Control.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ examples/advanced_analysis.py
 examples/basic_usage.py
 examples/batch_capture.py
 examples/continuous_capture.py
+examples/data_logger_basic.py
 examples/function_generator_basic.py
 examples/live_plot.py
 examples/measurements.py
@@ -47,6 +48,9 @@ scpi_control/awg_models.py
 scpi_control/awg_output.py
 scpi_control/awg_scpi_commands.py
 scpi_control/channel.py
+scpi_control/daq_models.py
+scpi_control/daq_scpi_commands.py
+scpi_control/data_logger.py
 scpi_control/exceptions.py
 scpi_control/function_generator.py
 scpi_control/math_channel.py
@@ -75,6 +79,7 @@ scpi_control/connection/visa_connection.py
 scpi_control/gui/__init__.py
 scpi_control/gui/app.py
 scpi_control/gui/connection_manager.py
+scpi_control/gui/daq_worker.py
 scpi_control/gui/live_view_worker.py
 scpi_control/gui/main_window.py
 scpi_control/gui/vnc_window.py
@@ -83,6 +88,11 @@ scpi_control/gui/utils/validators.py
 scpi_control/gui/widgets/__init__.py
 scpi_control/gui/widgets/channel_control.py
 scpi_control/gui/widgets/cursor_panel.py
+scpi_control/gui/widgets/daq_ai_panel.py
+scpi_control/gui/widgets/daq_channel_config.py
+scpi_control/gui/widgets/daq_data_view.py
+scpi_control/gui/widgets/daq_scan_config.py
+scpi_control/gui/widgets/data_logger_control.py
 scpi_control/gui/widgets/error_dialog.py
 scpi_control/gui/widgets/fft_display.py
 scpi_control/gui/widgets/math_panel.py
@@ -118,6 +128,9 @@ scpi_control/report_generator/llm/__init__.py
 scpi_control/report_generator/llm/analyzer.py
 scpi_control/report_generator/llm/client.py
 scpi_control/report_generator/llm/context_builder.py
+scpi_control/report_generator/llm/daq_analyzer.py
+scpi_control/report_generator/llm/daq_context_builder.py
+scpi_control/report_generator/llm/daq_prompts.py
 scpi_control/report_generator/llm/prompts.py
 scpi_control/report_generator/models/__init__.py
 scpi_control/report_generator/models/app_settings.py
@@ -139,4 +152,5 @@ scpi_control/report_generator/widgets/metadata_panel.py
 scpi_control/report_generator/widgets/pdf_preview_dialog.py
 scpi_control/report_generator/widgets/report_options_dialog.py
 scpi_control/report_generator/widgets/template_manager_dialog.py
-siglent/__init__.py
+siglent/__init__.py
+siglent/exceptions.py

scpi_instrument_control-1.1.0/examples/data_logger_basic.py

@@ -0,0 +1,147 @@
+"""Basic Data Logger / DAQ example.
+
+This example demonstrates basic usage of the DataLogger class for
+data acquisition systems like the Keysight 34970A/DAQ970A.
+
+Requirements:
+    - A SCPI-compatible DAQ system (Keysight 34970A, DAQ970A, or similar)
+    - Network connection to the instrument
+"""
+
+from scpi_control import DataLogger
+
+# Replace with your DAQ's IP address
+DAQ_IP = "192.168.1.100"
+
+
+def basic_measurements():
+    """Demonstrate basic voltage measurements."""
+    print("=== Basic Voltage Measurements ===\n")
+
+    with DataLogger(DAQ_IP) as daq:
+        print(f"Connected to: {daq.identify()}")
+        print(f"Model: {daq.model_capability.model_name}")
+        print(f"Channels available: {daq.model_capability.get_all_channels()}\n")
+
+        # Configure channels 101-103 for DC voltage measurement
+        channels = [101, 102, 103]
+        daq.configure_voltage_dc(channels, range="AUTO", resolution="AUTO")
+        print(f"Configured channels {channels} for DC voltage\n")
+
+        # Take immediate measurements
+        readings = daq.measure_voltage_dc(channels)
+        print("Measurement results:")
+        for reading in readings:
+            print(f"  Channel {reading.channel}: {reading.value:.6f} {reading.unit}")
+
+
+def scan_multiple_channels():
+    """Demonstrate scanning multiple channels."""
+    print("\n=== Multi-Channel Scan ===\n")
+
+    with DataLogger(DAQ_IP) as daq:
+        # Configure different measurement types on different channels
+        daq.configure_voltage_dc([101, 102], range="10")  # 10V range
+        daq.configure_temperature([103, 104], sensor_type="TC", sensor_subtype="K")
+        daq.configure_resistance([105], four_wire=False)
+
+        # Set up scan list
+        scan_channels = [101, 102, 103, 104, 105]
+        daq.set_scan_list(scan_channels)
+        print(f"Scan list: {daq.get_scan_list()}")
+
+        # Configure trigger for immediate single scan
+        daq.set_trigger_source("IMM")
+        daq.set_trigger_count(1)
+
+        # Initiate and read
+        readings = daq.read()
+        print(f"\nScanned {len(readings)} channels:")
+        for i, reading in enumerate(readings):
+            ch = scan_channels[i] if i < len(scan_channels) else "?"
+            print(f"  Channel {ch}: {reading.value:.6f}")
+
+
+def continuous_logging():
+    """Demonstrate continuous data logging."""
+    print("\n=== Continuous Logging (5 seconds) ===\n")
+
+    with DataLogger(DAQ_IP) as daq:
+        # Configure for voltage monitoring
+        channels = [101, 102]
+        daq.configure_voltage_dc(channels)
+
+        # Log at 1 second intervals for 5 seconds
+        print("Logging for 5 seconds...")
+        all_readings = daq.start_logging(
+            channels=channels,
+            interval=1.0,
+            duration=5.0,
+            callback=lambda r: print(f"  Got {len(r)} readings"),
+        )
+
+        print(f"\nTotal scans collected: {len(all_readings)}")
+        print(f"Total readings: {sum(len(r) for r in all_readings)}")
+
+
+def alarm_monitoring():
+    """Demonstrate alarm/limit checking."""
+    print("\n=== Alarm Monitoring ===\n")
+
+    with DataLogger(DAQ_IP) as daq:
+        if not daq.model_capability.has_alarm:
+            print("This model does not support alarm limits")
+            return
+
+        # Configure voltage measurement with limits
+        channel = 101
+        daq.configure_voltage_dc(channel)
+
+        # Set alarm limits: warn if voltage goes outside 0-5V
+        daq.set_alarm_limits(channel, high=5.0, low=0.0)
+        daq.enable_alarm(channel, enable=True)
+        print(f"Alarm limits set on channel {channel}: 0V to 5V")
+
+        # Take a measurement
+        readings = daq.measure_voltage_dc(channel)
+        print(f"Current reading: {readings[0].value:.3f} V")
+
+
+def scaling_example():
+    """Demonstrate mx+b scaling."""
+    print("\n=== Scaling (mx+b) Example ===\n")
+
+    with DataLogger(DAQ_IP) as daq:
+        if not daq.model_capability.has_math:
+            print("This model does not support scaling")
+            return
+
+        channel = 101
+        daq.configure_voltage_dc(channel)
+
+        # Apply scaling: convert 0-10V input to 0-100% display
+        # Scaled value = (reading * 10) + 0 = percentage
+        daq.set_scaling(channel, gain=10.0, offset=0.0, enable=True)
+        print("Scaling configured: 0-10V input -> 0-100% output")
+
+        readings = daq.measure_voltage_dc(channel)
+        print(f"Raw voltage: {readings[0].value:.3f} V")
+        # Note: scaled value would be returned if DAQ returns scaled data
+
+
+if __name__ == "__main__":
+    print("Data Logger / DAQ Basic Examples")
+    print("================================\n")
+
+    try:
+        basic_measurements()
+        # scan_multiple_channels()
+        # continuous_logging()
+        # alarm_monitoring()
+        # scaling_example()
+    except Exception as e:
+        print(f"Error: {e}")
+        print("\nMake sure:")
+        print(f"  1. Your DAQ is connected at {DAQ_IP}")
+        print("  2. The IP address is correct")
+        print("  3. No other software is using the connection")

{scpi_instrument_control-1.0.1 → scpi_instrument_control-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SCPI-Instrument-Control"
-version = "1.0.1"
+version = "1.1.0"
 description = "Universal Python library for controlling SCPI-compatible test equipment via Ethernet/LAN. Supports oscilloscopes (Siglent SDS series, generic SCPI scopes), function generators/AWGs (Siglent SDG series, generic SCPI AWGs), and power supplies (Siglent SPD series, generic SCPI PSUs). Features include waveform capture, measurements, FFT analysis, PyQt6 GUI, automated report generation with AI analysis, and comprehensive SCPI command abstraction."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.8"

{scpi_instrument_control-1.0.1 → scpi_instrument_control-1.1.0}/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_instrument_control-1.0.1 → scpi_instrument_control-1.1.0}/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_instrument_control-1.1.0/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()]