ad9740: Add pyadi-iio support

sarpadi · sarpadi · commit bf1bca10100d · 2025-12-17T12:55:39.000+02:00
diff --git a/adi/__init__.py b/adi/__init__.py
@@ -39,6 +39,7 @@
 from adi.ad7746 import ad7746
 from adi.ad7768 import ad7768, ad7768_4
 from adi.ad7799 import ad7799
+from adi.ad9740 import ad9740
 from adi.ad9081 import ad9081
 from adi.ad9081_mc import QuadMxFE, ad9081_mc
 from adi.ad9083 import ad9083
diff --git a/adi/ad9740.py b/adi/ad9740.py
@@ -0,0 +1,202 @@
+# Copyright (C) 2025 Analog Devices, Inc.
+#
+# SPDX short identifier: ADIBSD
+
+from decimal import Decimal
+
+from adi.attribute import attribute
+from adi.context_manager import context_manager
+from adi.rx_tx import tx
+
+
+class ad9740(tx, context_manager):
+    """AD9740/AD9742/AD9744/AD9748 10/12/14/8-bit, 210 MSPS DAC with DDS support"""
+
+    _complex_data = False
+    _device_name = "AD9740"
+
+    def disable_dds(self):
+        """Override DDS disable to use data_source attribute instead.
+
+        AD9740 uses data_source control, not the standard DDS raw attribute.
+        When switching to DMA mode, set data_source to 'normal'.
+        """
+        # Set data source to normal (DMA mode)
+        if hasattr(self, 'channel') and len(self.channel) > 0:
+            try:
+                self.channel[0].data_source = "normal"
+            except (AttributeError, OSError):
+                # If data_source doesn't work, just pass
+                # (driver might already be in correct mode)
+                pass
+
+    def __init__(self, uri="", device_name=""):
+        """Constructor for AD9740 driver class"""
+
+        context_manager.__init__(self, uri, self._device_name)
+
+        compatible_parts = [
+            "ad9740",  # 10-bit DAC
+            "ad9742",  # 12-bit DAC
+            "ad9744",  # 14-bit DAC
+            "ad9748",  # 8-bit DAC
+        ]
+
+        self._ctrl = None
+        self._txdac = None
+
+        if not device_name:
+            device_name = compatible_parts[0]
+        else:
+            if device_name not in compatible_parts:
+                raise Exception(
+                    f"Not a compatible device: {device_name}. Supported device names "
+                    f"are: {','.join(compatible_parts)}"
+                )
+
+        # Select the device matching device_name as working device
+        for device in self._ctx.devices:
+            if device.name == device_name:
+                self._ctrl = device
+                self._txdac = device
+                break
+
+        if not self._ctrl:
+            raise Exception("Error in selecting matching device")
+
+        if not self._txdac:
+            raise Exception("Error in selecting matching device")
+
+        self.output_bits = []
+        self.channel = []
+        self._tx_channel_names = []
+        for ch in self._ctrl.channels:
+            name = ch._id
+            output = ch._output
+            self.output_bits.append(ch.data_format.bits)
+            self._tx_channel_names.append(name)
+            self.channel.append(self._channel(self._ctrl, name, output))
+            if output is True:
+                setattr(self, name, self._channel(self._ctrl, name, output))
+
+        tx.__init__(self)
+
+    class _channel(attribute):
+        """AD9740 channel"""
+
+        def __init__(self, ctrl, channel_name, output):
+            self.name = channel_name
+            self._ctrl = ctrl
+            self._output = output
+
+        @property
+        def sample_rate(self):
+            """Sample rate of the DAC (from backend)
+            Note: AD9740 driver doesn't expose sampling_frequency attribute,
+            so we return a default value. Override if needed."""
+            try:
+                return self._get_iio_attr(self.name, "sampling_frequency", True)
+            except (KeyError, OSError):
+                # Attribute doesn't exist, return default (210 MHz from ADF4351)
+                return 210000000
+
+        @sample_rate.setter
+        def sample_rate(self, value):
+            """Set sample rate - may not be supported by all backends"""
+            try:
+                self._set_iio_attr(self.name, "sampling_frequency", True, value)
+            except (KeyError, OSError):
+                # Attribute doesn't exist, silently ignore
+                pass
+
+        @property
+        def raw(self):
+            """Get channel raw value
+            DAC code in the range 0-16383 (14-bit)"""
+            return self._get_iio_attr(self.name, "raw", True)
+
+        @raw.setter
+        def raw(self, value):
+            """Set channel raw value"""
+            self._set_iio_attr(self.name, "raw", True, str(int(value)))
+
+        @property
+        def data_source(self):
+            """Get/Set data source: normal, dds, or ramp"""
+            return self._get_iio_attr_str(self.name, "data_source", True)
+
+        @data_source.setter
+        def data_source(self, value):
+            """Set data source (normal, dds, ramp)"""
+            self._set_iio_attr(self.name, "data_source", True, value)
+
+        @property
+        def data_source_available(self):
+            """Available data sources"""
+            return self._get_iio_attr_str(self.name, "data_source_available", True)
+
+        # DDS Tone 0 controls
+        @property
+        def frequency0(self):
+            """DDS Tone 0 frequency in Hz"""
+            return int(self._get_iio_attr(self.name, "frequency0", True))
+
+        @frequency0.setter
+        def frequency0(self, value):
+            self._set_iio_attr(self.name, "frequency0", True, str(int(value)))
+
+        @property
+        def scale0(self):
+            """DDS Tone 0 scale (0.0 to 1.0)"""
+            return float(self._get_iio_attr_str(self.name, "scale0", True))
+
+        @scale0.setter
+        def scale0(self, value):
+            self._set_iio_attr(self.name, "scale0", True, str(Decimal(value).real))
+
+        @property
+        def phase0(self):
+            """DDS Tone 0 phase in degrees"""
+            # Kernel returns phase in radians as a decimal string
+            radians = float(self._get_iio_attr_str(self.name, "phase0", True))
+            return radians * 180.0 / 3.14159265359  # Convert to degrees
+
+        @phase0.setter
+        def phase0(self, value):
+            """Set phase in degrees"""
+            # Convert degrees to radians for kernel
+            radians = float(value) * 3.14159265359 / 180.0
+            self._set_iio_attr(self.name, "phase0", True, f"{radians:.5f}")
+
+        # DDS Tone 1 controls
+        @property
+        def frequency1(self):
+            """DDS Tone 1 frequency in Hz"""
+            return int(self._get_iio_attr(self.name, "frequency1", True))
+
+        @frequency1.setter
+        def frequency1(self, value):
+            self._set_iio_attr(self.name, "frequency1", True, str(int(value)))
+
+        @property
+        def scale1(self):
+            """DDS Tone 1 scale (0.0 to 1.0)"""
+            return float(self._get_iio_attr_str(self.name, "scale1", True))
+
+        @scale1.setter
+        def scale1(self, value):
+            self._set_iio_attr(self.name, "scale1", True, str(Decimal(value).real))
+
+        @property
+        def phase1(self):
+            """DDS Tone 1 phase in degrees"""
+            # Kernel returns phase in radians as a decimal string
+            radians = float(self._get_iio_attr_str(self.name, "phase1", True))
+            return radians * 180.0 / 3.14159265359  # Convert to degrees
+
+        @phase1.setter
+        def phase1(self, value):
+            """Set phase in degrees"""
+            # Convert degrees to radians for kernel
+            radians = float(value) * 3.14159265359 / 180.0
+            self._set_iio_attr(self.name, "phase1", True, f"{radians:.5f}")
diff --git a/examples/ad9740_dds.py b/examples/ad9740_dds.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+Simple DDS signal generator for AD974x DACs with waveform display.
+
+Usage:
+    python3 ad9740_dds.py -f 1e6 -s 0.5
+    python3 ad9740_dds.py --frequency 5000000 --scale 1.0
+    python3 ad9740_dds.py -f 1e6 -s 0.5 --device ad9744
+"""
+
+import argparse
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+import adi
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generate DDS signal on AD974x DAC',
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog="""Examples:
+  ad9740_dds.py -f 1e6 -s 0.5          # 1 MHz at 50% scale
+  ad9740_dds.py -f 5000000 -s 1.0      # 5 MHz at full scale
+  ad9740_dds.py -f 100e3 -s 0.25       # 100 kHz at 25% scale
+  ad9740_dds.py -f 1e6 --device ad9744 # Use AD9744 device"""
+    )
+    parser.add_argument('-f', '--frequency', type=float, required=True,
+                        help='Output frequency in Hz (e.g., 1e6 for 1 MHz)')
+    parser.add_argument('-s', '--scale', type=float, default=1.0,
+                        help='Output scale 0.0-1.0 (default: 1.0)')
+    parser.add_argument('-u', '--uri', type=str, default='ip:10.48.65.163',
+                        help='Device URI (default: ip:10.48.65.163)')
+    parser.add_argument('-d', '--device', type=str, default='ad9744',
+                        choices=['ad9748', 'ad9740', 'ad9742', 'ad9744'],
+                        help='DAC device name (default: ad9744)')
+
+    args = parser.parse_args()
+
+    # Validate parameters
+    if args.frequency <= 0:
+        print(f"Error: Frequency must be positive, got {args.frequency}")
+        sys.exit(1)
+
+    if not 0.0 <= args.scale <= 1.0:
+        print(f"Error: Scale must be between 0.0 and 1.0, got {args.scale}")
+        sys.exit(1)
+
+    # Connect to DAC
+    print(f"Connecting to {args.device} at {args.uri}...")
+
+    try:
+        dac = adi.ad9740(uri=args.uri, device_name=args.device)
+    except Exception as e:
+        print(f"Error connecting to DAC: {e}")
+        sys.exit(1)
+
+    # Configure DDS
+    try:
+        dac.channel[0].data_source = 'dds'
+        dac.channel[0].frequency0 = int(args.frequency)
+        dac.channel[0].scale0 = args.scale
+
+        freq_str = f"{args.frequency/1e6:.3f} MHz" if args.frequency >= 1e6 else f"{args.frequency/1e3:.3f} kHz"
+        print(f"DDS configured: {freq_str} at scale {args.scale:.2f}")
+
+    except Exception as e:
+        print(f"Error configuring DDS: {e}")
+        sys.exit(1)
+
+    # Generate expected waveform for display
+    num_cycles = 4
+    samples_per_cycle = 100
+    num_samples = num_cycles * samples_per_cycle
+
+    t = np.linspace(0, num_cycles / args.frequency, num_samples)
+    waveform = args.scale * np.sin(2 * np.pi * args.frequency * t)
+
+    # Convert time to appropriate units for display
+    if args.frequency >= 1e6:
+        t_display = t * 1e6  # microseconds
+        t_unit = 'us'
+    elif args.frequency >= 1e3:
+        t_display = t * 1e3  # milliseconds
+        t_unit = 'ms'
+    else:
+        t_display = t
+        t_unit = 's'
+
+    # Create plot
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.plot(t_display, waveform, 'b-', linewidth=1.5)
+    ax.axhline(y=0, color='gray', linestyle='--', linewidth=0.5)
+    ax.set_xlabel(f'Time ({t_unit})')
+    ax.set_ylabel('Amplitude (normalized)')
+    ax.set_title(f'{args.device.upper()} DDS Output: {freq_str} @ {args.scale:.0%} scale')
+    ax.set_ylim(-1.1, 1.1)
+    ax.grid(True, alpha=0.3)
+
+    # Add info text
+    info_text = f"Frequency: {freq_str}\nScale: {args.scale:.2f}\nDevice: {args.device}"
+    ax.text(0.02, 0.98, info_text, transform=ax.transAxes, fontsize=10,
+            verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+
+    plt.tight_layout()
+    print("Close the plot window to stop DDS and exit.")
+    plt.show()
+
+    print("DDS stopped.")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/examples/ad9740_dma.py b/examples/ad9740_dma.py
