nsqdriver 0.3.1__cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

nsqdriver/wrapper/BD_NSMCI.py

@@ -0,0 +1,310 @@
+import time
+from typing import Dict, Any, List
+
+import numpy as np
+
+from nsqdriver import MCIDriver, QSYNCDriver
+
+
+try:
+    import Instrument
+except ImportError as e:
+    class Instrument(object):
+        ...
+
+
+class NSInstrument(Instrument):
+    """ Instrument for GuoDun devices """
+    ParameterMC = {
+        'OUTSrate': 8e9,      # 配置OUT通道采样率
+        'OUTMix': 2,          # 设置OUT通道增强第二奈奎斯特区信号
+        'INZone': 'zone3'     # 设置IN通道输入为Zone4，即要IN通道要采集的信号范围为6~8G
+    }
+    ParameterZ = {
+        'OUTSrate': 2e9,      # 配置OUT通道采样率
+        'OUTMix': 1,          # 设置OUT通道增强第一奈奎斯特区信号
+        'KeepAmp': 2          # 开启Z通道的保持电平模式，2为保持drive信号电平
+    }
+    ParameterQSYNC = {
+        'RefClock': 'in'      # MC112的100M参考信号来源，机箱上的100M IN没有接的情况下，选择为in，反之选out
+    }
+
+    def __init__(self):
+        """ Initialization """
+        super(NSInstrument, self).__init__()
+
+        # 设备驱动
+        self.driver_mc: MCIDriver = MCIDriver('192.168.111.152')
+        self.driver_z: MCIDriver = MCIDriver('192.168.111.132')
+        self.qsync: QSYNCDriver = QSYNCDriver('192.168.111.152')
+
+        # 参数
+        self.waves = dict()
+        self.roFreq = dict()
+        self.roQubits = dict()
+        self.roLength = dict()
+        self.roDADelay = dict()
+        self.zpdc = dict()
+        self.group = dict()
+        self.roLines = dict()
+        self.connectDict = dict()
+        self.deviceDict = dict()
+        self.qubitROChannels = dict()
+        self.integrationDelay = dict()
+        self.inputRange = dict()
+        self.outputRange = dict()
+        self.devices = {
+            'awg': self.driver_mc,
+            'dc': self.driver_z,
+            'qa': self.driver_mc,
+        }  # type: Dict[str, Any]
+        self.shots = 1000
+        self.devicesList = {
+            'awg': [],
+            'dc': [],
+            'qa': []
+        }  # type: Dict[str, Any]
+
+    def connectDevices(self, *args, **kwargs):
+        """ Connect and initialize devices """
+        if 'devices' not in kwargs.keys():
+            raise ValueError('Parameter `devices` does not exist in connectDevices().')
+        if 'connect' not in kwargs.keys():
+            raise ValueError('Parameter `connect` does not exist in connectDevices().')
+        if 'roLines' not in kwargs.keys():
+            raise ValueError('Parameter `roLines` does not exist in connectDevices().')
+
+        self.roLines = kwargs['roLines']
+        """
+        The readout line dict. Example:
+        {"r1":["q01","q02","q03","q04","q05"], "r2": ["q06","q07","q08","q09","q10"], ...}
+        """
+
+        self.deviceDict = kwargs['devices']
+        """
+        The dict for all devices. Example:
+        {
+            "XY":["mc_1", ...],
+            "Z":["z_1", ...],
+            "ZDC":["z_1", ...],
+            "RO":["out01", "out09", ...],
+            "QA":["in01", "in09", ...]
+        }
+        """
+
+        self.connectDict = kwargs['connect']
+        """
+        The mapping between device channels and logical channels. Example:
+        {
+            "QA": {"r1QA": ["in01", "range(20)"], "r2QA": ["in09", "range(20)"], ...},
+            "RO": {"r1RO": ["out01", "range(20)"], "r2RO": ["out09", "range(20)"], ...},
+            "RO_qubits": {"q01RO": "r1RO", "q02RO": "r1RO", "q03RO": "r1RO", ...},
+            "RO_trig": {"r1RO": "AWG5M1", "r2RO": "AWG5M1", ...},
+            "XY": {"q03XY": ["mc_1", "out03"], "q04XY": ["mc_1", "out04"], ...},
+            "Z": {"q03Z": ["z_1", "out01"], "q04Z": ["z_1", "out02"]}
+        }
+
+        """
+
+        # Parse readout channels
+        for _line, _qubits in self.roLines.items():
+            ro_channels = [i for i in eval(self.connectDict['RO'][f'{_line}RO'][1])]
+            if len(ro_channels) != len(_qubits):
+                raise RuntimeError(f'Qubit number in {_line} does not equal to '
+                                   f'the number of channels ({ro_channels}).')
+            for _q, _c in zip(self.roLines[_line], ro_channels):
+                self.qubitROChannels[f'{_q}RO'] = _c
+
+        # Connect device
+        # 在kw参数中寻找系统初始化相关参数
+        qs_sp = self.ParameterQSYNC.copy()
+        qs_sp.update(kwargs.get('qs_param', {}))
+        mc_sp = self.ParameterMC.copy()
+        mc_sp.update(kwargs.get('mc_param', {}))
+        z_sp = self.ParameterZ.copy()
+        z_sp.update(kwargs.get('z_param', {}))
+
+        self.qsync.open(system_parameter=qs_sp)
+        self.driver_mc.open(system_parameter=mc_sp)
+        self.driver_z.open(system_parameter=z_sp)
+        self.qsync.sync_system()
+
+    def _rline2chnl(self, rline):
+        return int(self.connectDict['QA'][f'{rline}QA'][0][-2:])
+
+    def _xy2chnl(self, _key):
+        return int(self.connectDict['XY'][_key][1][-2:])
+
+    def _z2chnl(self, _key):
+        return int(self.connectDict['Z'][_key][1][-2:])
+
+    def _qubit2rline(self, qubit):
+        return self.connectDict['RO_qubits'][f'{qubit}RO'][:2]
+
+    def disconnectDevices(self, *args, **kwargs):
+        """ Initialize devices """
+        ...
+
+    # def expendBatchChannels(self):
+
+    def stopOutput(self, *args, **kwargs):
+        """ Stop the output of waveforms """
+        self.qsync.set('ResetTrig')
+
+    def startOutput(self, *args, **kwargs):
+        """ Stop the output of waveforms """
+        self.qsync.set('GenerateTrig')
+
+    def uploadWaveforms(self, *args, **kwargs):
+        """ Upload waveforms """
+        if 'waves' not in kwargs.keys():
+            raise ValueError('Parameter `waves` does not exist in uploadWaveforms().')
+        if 'zpdc' not in kwargs.keys():
+            raise ValueError('Parameter `zpdc` does not exist in uploadWaveforms().')
+
+        self.setINDemod(**kwargs)
+        self.setRODADelay(**kwargs)
+        self.zpdc = kwargs['zpdc']
+
+        waves = kwargs['waves']
+        waves_map = {}
+        for _key, _wave in waves.items():
+            _devChannel = None
+            if _key in self.connectDict['XY'].keys():
+                _devChannel = self._xy2chnl(_key)
+                self.driver_mc.set('Waveform', _wave, _devChannel)
+            elif _key in self.connectDict['Z'].keys():
+                _devChannel = self._z2chnl(_key)
+                self.driver_mc.set('Waveform', _wave, _devChannel)
+            elif _key in self.qubitROChannels.keys():
+                _devChannel = self._qubit2rline(_key)
+                wave_list = waves_map.get(_devChannel, [])
+                wave_list.append(_wave)
+            if _devChannel is None:
+                raise RuntimeError(f'Channel {_key} does not found.')
+            print(_key, _devChannel, len(_wave))
+
+        # 合并下发probe da波形
+        for _line, wave_list in waves_map.items():
+            max_points = max(_w.size() for _w in wave_list)
+            wave_array = np.zeros((len(self.roLines[_line]), max_points))
+            for idx, _w in enumerate(wave_list):
+                wave_array[idx][:_w.size()] = _w
+            self.driver_mc.set('Waveform', wave_array.mean(axis=0), self._rline2chnl(_line))
+
+        # import matplotlib.pyplot as plt
+        # for _key, _seq in self.waves.items():
+        #     plt.plot(_seq, label=_key)
+        # plt.legend()
+        # plt.show()
+
+    def downloadIQ(self, *args, **kwargs):
+        """ Download IQ data """
+        self.setIntegrationDelay(**kwargs)
+        self.startOutput()
+        st_time = time.time()
+        roChannels = {}
+        print('self.roQubits', self.roQubits)
+        for _r in self.roQubits.keys():
+            roChannels[_r] = [self.qubitROChannels[f'{_q}RO'] for _q in self.roQubits[_r]]
+        print('roChannels', roChannels)
+        full = {
+            _r: self.driver_mc.get('IQ', channel=self._rline2chnl(_r))
+            for _r in self.roQubits.keys()
+        }
+        print('get iq data timing:', time.time() - st_time)
+
+        iqDict = dict()
+        for qubit, iqData in zip(self.roQubits.values(), full.values()):
+            for _q in qubit:
+                iqDict[_q] = iqData[self.qubitROChannels[f'{_q}RO']]
+        return iqDict
+
+    def setINDemod(self, *args, **kwargs):
+        """!
+        配置MC设备的解模系数
+        @param args:
+        @param kwargs:
+        @return:
+        """
+        if 'roQubits' not in kwargs.keys():
+            raise ValueError('Parameter `roQubits` does not exist in uploadWaveforms().')
+        if 'roLength' not in kwargs.keys():
+            raise ValueError('Parameter `roLength` does not exist in uploadWaveforms().')
+        if 'roFreq' not in kwargs.keys():
+            raise ValueError('Parameter `roFreq` does not exist in uploadWaveforms().')
+        self.roQubits = kwargs['roQubits']
+        self.roLength = {_line: [length / 1e9 for length in lengths] for _line, lengths in kwargs['roLength'].items()}
+        self.roFreq = {_line: [freq / 1e9 for freq in freqs] for _line, freqs in kwargs['roFreq'].items()}
+
+        for _line, qubits in self.roQubits.items():
+            freqs = {_q: 1e9 for _q in self.roLines[_line]}
+            lengths = {_q: 512e-9 for _q in self.roLines[_line]}
+            for _q, _freq, _len in zip(qubits, self.roFreq[_line], self.roLength[_line]):
+                freqs[_q] = _freq
+                lengths[_q] = _len
+            print(f'The configured demodulation frequency point is ({freqs})')
+            self.driver_mc.set('TimeWidth', list(lengths.values()), self._rline2chnl(_line))
+            self.driver_mc.set('FreqList', max(freqs.values()), self._rline2chnl(_line))
+
+    def setRODADelay(self, *args, **kwargs):
+        """!
+        配置probe da相对触发的延迟
+        配置粒度为16ns的整倍数
+        @param args:
+        @param kwargs:
+        @return:
+        """
+        if 'roDADelay' in kwargs.keys():
+            for _line, delay in kwargs['roDADelay'].items():
+                self.roDADelay[_line] = delay/1e9
+                self.driver_mc.set('OUTDelay', self.roDADelay[_line], self._rline2chnl(_line))
+        else:
+            raise ValueError('Parameter `roDADelay` does not exist in uploadWaveforms().')
+
+    def setShots(self, *args, **kwargs):
+        """ Set shots """
+        if 'shots' not in kwargs.keys():
+            raise ValueError('Parameter `shots` does not exist in setShots().')
+        shots = kwargs['shots']
+        self.shots = shots
+        self.qsync.set('Shot', shots)
+        self.driver_mc.set('Shot', shots)
+        print("set shots:", shots)
+
+    def setHoldoffTime(self, *args, **kwargs):
+        """ Set hold-off time """
+        if 'interval' not in kwargs.keys():
+            raise ValueError('Parameter `interval` does not exist in setHoldoffTime().')
+        interval = kwargs['interval']
+        self.qsync.set('TrigPeriod', interval / 1e9)  # 单位：s
+
+    def setLO(self, *args, **kwargs):
+        """ Set LO """
+        ...
+
+    def setIntegrationDelay(self, *args, **kwargs):
+        """ Set readout integration delay. """
+        if 'integrationDelay' in kwargs.keys():
+            for _channel, delay in kwargs['integrationDelay'].items():
+                self.integrationDelay[_channel] = delay
+                self.driver_mc.set('INDelay', delay / 1e9, self._rline2chnl(_channel))
+        else:
+            raise ValueError('Parameter `integrationDelay` does not exist in setIntegrationDelay().')
+
+    def setInputRange(self, *args, **kwargs):
+        """ Set input range for output channels """
+        if 'inputRange' in kwargs.keys():
+            for _channel, _value in kwargs['inputRange'].items():
+                devChannel = self.connectDict['QA'][_channel][1]
+                self.inputRange[devChannel] = _value
+        else:
+            raise ValueError('Parameter `inputRange` does not exist in setInputRange().')
+
+    def setOutputRange(self, *args, **kwargs):
+        """ Set output range for output channels """
+        if 'outputRange' in kwargs.keys():
+            for _channel, delay in kwargs['outputRange'].items():
+                self.outputRange[_channel] = delay
+        else:
+            raise ValueError('Parameter `outputRange` does not exist in setOutputRange().')

nsqdriver/wrapper/ND_NSMCI.py

@@ -0,0 +1,245 @@
+import numpy as np
+from nsqdriver import MCIDriver, QSYNCDriver
+
+
+class _XYChannel:
+    def __init__(self, mci: "DeviceBase", ch=1):
+        self.mci = mci
+        self.ch = ch
+        self.to_zero = np.zeros((16,))
+        self.to_one = np.ones((16,))
+        self.en = True
+        self.mode = 0
+        self.off = 0
+
+    def wave(self, w):
+        self.wavex(w, self.ch)
+
+    def wavex(self, w, idx):
+        if np.max(np.abs(w)) < 1e-30:
+            wr = np.zeros(16)
+        else:
+            wr = w
+        self.mci.mci_driver.set("Waveform", wr, idx)
+
+    def arm(self, k=None):
+        self.mci.mci_driver.set('PushWaveCache')
+
+    def trig_del(self, delay):
+        ...
+
+    def output_del(self, delay):
+        ...
+
+    def __del__(self):
+        pass
+
+    def output(self, b):
+        self.en = bool(b)
+        if not self.en:
+            self.mci.mci_driver.set("Waveform", self.to_zero, self.ch)
+
+    def mode(self, m_):
+        ...
+
+    def offsetx(self, off, idx):
+        self.mci.mci_driver.set('Waveform', off*self.to_one, idx)
+        self.off = off
+
+    def offset(self, off):
+        self.offsetx(off, self.ch)
+
+    W = {
+        "wave": wave,
+        "output": output,
+        "trig_del": trig_del,
+        "output_del": output_del,
+        "mode": mode,
+        "offset": offset,
+    }
+
+    Q = {"arm": arm}
+
+
+class _ZChannel(_XYChannel):
+    pass
+
+
+class _Probe:
+    def __init__(self, mci: "DeviceBase", ch=1):
+        self.mci = mci
+        self.ch = ch
+        self.freqList = []
+        self.SGS = None  # single shot temp cache
+        self.AVG = None  # average temp cache
+        self.depth = 2000
+        self._width = 1000
+        self.start = 500
+        self.demod = 1
+        self.averaged_I = np.zeros((16384, ))  # 直播直采，相当于只有I路数据
+
+    def depth(self, depth_):
+        self.depth = depth_
+        self.mci.mci_driver.set('PointNumber', depth_, self.ch)
+
+    def demodulation_on(self, demod_):
+        self.demod = int(demod_)
+
+    def start(self, start_):
+        self.start = start_
+        self.mci.mci_driver.set('TriggerDelay', start_, self.ch)
+
+    def width(self, width_):
+        self._width = width_/4e9
+        self.mci.mci_driver.set('PointNumber', width_, self.ch)
+
+    def freqs(self, *freqList_):
+        self.freqList = freqList_
+        self.mci.mci_driver.set('FreqList', freqList_, self.ch)
+
+    def shot(self, _shot):
+        self.mci.mci_driver.set('Shot', _shot)
+
+    def measure(self, k=None):
+        self.mci.mci_driver.set('StartCapture')
+        if self.demod:
+            self.SGS = self.mci.mci_driver.get('IQ', self.ch)
+            self.AVG = np.mean(self.SGS, axis=0)
+        else:
+            self.averaged_I = np.mean(self.mci.mci_driver.get('TraceIQ', self.ch), axis=0)
+
+    def single_shot(self, k=None):
+        return self.SGS
+
+    def average(self, k=None):
+        return self.AVG
+
+    def trace_I(self, k=None):
+        return self.averaged_I
+
+    def trace_Q(self, k=None):
+        return self.averaged_I
+
+    def __del__(self):
+        pass
+
+    W = {
+        "demod": demodulation_on,
+        "depth": depth,
+        "width": width,
+        "start": start,
+        "freqs": freqs,
+        "shot": shot,
+    }
+
+    Q = {
+        "measure": measure,
+        "A": average,
+        "S": single_shot,
+        "traceI": trace_I,
+        "traceQ": trace_Q
+    };
+
+
+# one box need one class
+class DeviceBase:
+    def __init__(self):
+        self.mci_driver = MCIDriver('127.0.0.1')
+        self.qsync_driver = QSYNCDriver('127.0.0.1')
+
+
+class NS_MCI(DeviceBase):
+    def __init__(self, addr, srate=10e9, mixmode=2, ref_clk='in'):
+        """!
+        此类涉及到系统同步，放到最后实例化
+        @param addr: 设备ip
+        @param srate: OUT通道采样率
+        @param mixmode: 为2时开启OUT通道混合模式，增强第二奈奎斯特区输出
+        @param ref_clk: 设备参考信号来源，不接外输出100M时都配置为'in'
+        """
+        super(NS_MCI, self).__init__()
+        self.mci_driver = MCIDriver(addr)
+        self.qsync = QSYNCDriver(addr)
+        self.srate = srate
+        self.mixmode = mixmode
+        self.ref_clk = ref_clk
+        self.connect()
+
+    def connect(self):
+        mci_params = {'DArate': self.srate, 'MixMode': self.mixmode}
+        qsync_params = {'RefClock': self.ref_clk}
+
+        self.qsync.open(system_parameter=qsync_params)
+        self.mci_driver.open(system_parameter=mci_params)
+        self.qsync.sync_system()
+
+        self.mci_driver.set('EnableWaveCache', True)
+
+        for _ch in range(22):
+            xy_ch = _ch+1
+            setattr(self, f'OUT{xy_ch}', _XYChannel(self, xy_ch))
+        for _ch in range(2):
+            probe_ch = _ch+1
+            setattr(self, f'IN{probe_ch}', _Probe(self, probe_ch))
+
+    def trig_interval(self, interval):
+        self.interval = interval
+        self.qsync.set('TrigPeriod', int(interval))
+
+    def trig_count(self, count_):
+        self.qsync.set('Shot', int(count_))
+
+    def trig(self):
+        self.qsync.set('GenerateTrig', self.interval)
+
+    def awg_arm(self):
+        self.mci_driver.set('PushWaveCache')
+
+    def __del__(self):
+        pass
+
+    W = {
+        "trig_interval": trig_interval,
+        "trig_count": trig_count,
+        "connect": connect,
+        "trig": trig,
+        "awg_arm": awg_arm,
+    }
+
+    Q = {
+    }
+
+
+class NS_Z(DeviceBase):
+    def __init__(self, addr, mixmode=2):
+        """!
+        此类负责控制24 Z OUT通道的设备，采样率固定为2Gsps，mixmode固定为1
+        @param addr: 设备ip
+        @param mixmode: 为1时关闭OUT通道混合模式
+        """
+        super(NS_Z, self).__init__()
+        self.mci_driver = MCIDriver(addr)
+        self.qsync = QSYNCDriver(addr)
+        self.srate = 2e9
+        self.mixmode = 1
+        self.connect()
+
+    def connect(self):
+        mci_params = {'DArate': self.srate, 'MixMode': self.mixmode}
+        self.mci_driver.open(system_parameter=mci_params)
+
+        self.mci_driver.set('EnableWaveCache', True)
+
+        for _ch in range(24):
+            xy_ch = _ch+1
+            setattr(self, f'OUT{xy_ch}', _ZChannel(self, xy_ch))
+
+    def awg_arm(self):
+        self.mci_driver.set('PushWaveCache')
+
+    W = {
+        "connect": connect,
+    }
+
+    Q = {
+    }

nsqdriver-0.3.1.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: nsqdriver
+Version: 0.3.1
+Summary: Naishu Q series quantum measurement and control equipment driver interface
+Home-page: https://g2hoyqcmh4.feishu.cn/wiki/wikcnzvyMd82DLZUe2NsI6HxsFc
+Author: Naishu Technology
+Author-email: jilianyi@naishu.tech
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy (>=1.18)
+Requires-Dist: waveforms
+
+```
+  _   _   ____     ___    ____           _                       
+ | \ | | / ___|   / _ \  |  _ \   _ __  (_) __   __   ___   _ __ 
+ |  \| | \___ \  | | | | | | | | | '__| | | \ \ / /  / _ \ | '__|
+ | |\  |  ___) | | |_| | | |_| | | |    | |  \ V /  |  __/ | |   
+ |_| \_| |____/   \__\_\ |____/  |_|    |_|   \_/    \___| |_|   
+```
+
+[![Tests](https://github.com/mianyan-echo/UltraMCI/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/mianyan-echo/UltraMCI/)
+***
+
+### 简介
+NSQDriver为一套耐数®量子测控系列设备的Python通用驱动接口。可使用Python作为编程语言，基于此驱动接口可以实现对本公司测控设备的控制，进而完成各种超导量子芯片的表征实验和高保真门操作。
+
+```
+                              +------------------------+
+                              |          Python        |
+                              |     +------------------+
+                              |     |      NSQDriver   |
+                              +------------------------+
+                                     :     :         :
+                           +----------     :         -----+
+                           :               :              :
+                           V               V              V
+                     +-----------+   +-----------+   +-----------+   
+                     |  Device A |   |  Device B |   |   QSYNC   |    
+                     +-----------+   +-----------+   +-----------+   
+```
+
+NSQDriver接口可用于统一控制耐数®生产的Q100、MC、QSYNC等一系列量子测控仪器，可详细控制每台仪器每个OUT、IN通道的播放与采集行为，以及查看设备的运行状态等。在一个多台测控设备组成的多量子比特测控系统中，可以有效的在软件层面实现对系统中每台设备的详细控制。
+
+耐数®量子测控系列设备详细信息参考: [耐数](http://naishu.tech)
+
+***
+### 快速开始
+- 驱动接口的通用流程如下
+```python
+from nsqdriver import MCIDriver, QSYNCDriver
+
+# 实例化设备驱动接口
+driver = MCIDriver('127.0.0.1')
+qsync = QSYNCDriver('127.0.0.1')
+
+# 连接设备
+qsync.open()
+driver.open()
+
+# 初始化系统
+qsync.sync_system()
+
+
+# 相关参数，参数细节相关参考 8.可用参数列表
+driver.set('Shot', 1024)
+```
+
+- NSWave接口
+  - NSWave是一种对于耐数®参数化波形技术的控制接口，参数化波形将量子测控所需的各种门的编辑由主控计算机直接生成波形转化成了设备实时计算
+  - 提供了一套直观的时序编辑接口
+```python
+from nsqdriver import InsChannel
+import numpy as np
+
+ch = InsChannel()                        # 生成参数化波形通道实例
+
+frame_65e9 = ch.ins_frame(6.5e9)         # 生成一个frame
+frame_67e9 = ch.ins_frame(6.7e9)         # 生成一个frame
+
+gaussian = ch.evlp_gaussian(4500e-9)     # 生成一个高斯包络
+square = ch.evlp_square(2500e-9)         # 生成一个方波包络
+
+wave1 = gaussian * frame_67e9            # 生成一段高斯包络的波形
+wave2 = square * frame_65e9              # 生成一段方波包络的波形
+
+ch.ins_reset_frame('phase', frame_65e9)
+ch.ins_reset_frame('phase', frame_67e9)
+ch.wait_for_trigger()                    # 等待触发到来
+# 循环播放200次 3μs延迟+ 7μs波形
+with ch.ins_loop(times=200) as _loop:
+    _loop.play_zero(3000e-9)
+    _loop.inc_phase(frame_65e9, np.pi / 2)
+    _loop.play_wave(wave2)
+    _loop.play_wave(wave1)
+```

nsqdriver-0.3.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+nsqdriver/NS_MCI.py,sha256=ZRf_waF7Q3VnClZnvjogfhVkqW7ltmwZaXXCRU8qA0o,19542
+nsqdriver/common.py,sha256=IHfShqgNN3THbe7KD7ICdfFY7JKC_kQj0_KJk-449gQ,499
+nsqdriver/__init__.py,sha256=2lrBt7MFoKL3MpN4Mc_8fS3vfUlUQZsV5p3gEVKz7d4,371
+nsqdriver/NS_CST.py,sha256=_QYCjg1YglIJ4YVmxvISqvy5rExWGlMhyrK9zYIRbRY,7877
+nsqdriver/NS_QSYNC.py,sha256=68qFZ04KVXb0MSaeKIZVZYqR0UV_tkJYWz7KSz4Dvg0,23281
+nsqdriver/_hold.cpython-311-x86_64-linux-gnu.so,sha256=a6QGRv7ztsNirQesKXppOQ5WoDotWTHsL9njAvdBkMs,23888
+nsqdriver/setup.py,sha256=NoLYEnI8fThgiiAb7tEQ0zEtoBKfuhhosTzKOGoPQTU,665
+nsqdriver/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsqdriver/compiler/py_wave_asm.cpython-311-x86_64-linux-gnu.so,sha256=40TR1nwzvqfMzQt1Qa-Di5AaXmO-spq074eOkf7ciXg,1824232
+nsqdriver/compiler/ns_wave.cpython-311-x86_64-linux-gnu.so,sha256=onrbHevSKrKumFwA68s8vI1yI9_69xXH3FvS1XABcPQ,1650288
+nsqdriver/wrapper/ND_NSMCI.py,sha256=gTyrDObhbggl35V_q-kpDoPsfttIEnDFc6f0-pk_P0k,6288
+nsqdriver/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsqdriver/wrapper/AWG_ADC.py,sha256=8K5xLEa_3CKnStWcoJeTj8ufEQfrx6o4l4XGNuOP3Ug,19211
+nsqdriver/wrapper/BD_NSMCI.py,sha256=SMnDbS6iXDiPBhoR9QVJB_lJXhIXRQIVLJRSBEihLzw,12245
+nsqdriver-0.3.1.dist-info/METADATA,sha256=Rq6R2BmH7_nnDkV-CVCeXNOJvpQnPtPVmuBh4UmOWkk,4315
+nsqdriver-0.3.1.dist-info/RECORD,,
+nsqdriver-0.3.1.dist-info/top_level.txt,sha256=o7EbQoFO6BoaG3KGbS9Lg_aRheZSY5KYzoYuI9vx-AI,10
+nsqdriver-0.3.1.dist-info/WHEEL,sha256=8KU227XctfdX2qUwyjQUO-ciQuZtmyPUCKmeGV6Byto,152

nsqdriver-0.3.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_x86_64
+Tag: cp311-cp311-manylinux2014_x86_64
+

nsqdriver-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+nsqdriver