nsqdriver 0.2.3__tar.gz → 0.2.5__tar.gz

{nsqdriver-0.2.3 → nsqdriver-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nsqdriver
-Version: 0.2.3
+Version: 0.2.5
 Summary: Naishu Q series quantum measurement and control equipment driver interface
 Home-page: https://g2hoyqcmh4.feishu.cn/wiki/wikcnzvyMd82DLZUe2NsI6HxsFc
 Author: Naishu Technology

{nsqdriver-0.2.3 → nsqdriver-0.2.5}/README.md

@@ -1,6 +1,8 @@
-# UltraMCI
+# UltraMCI ()
+
 [![Tests](https://github.com/mianyan-echo/UltraMCI/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/mianyan-echo/UltraMCI/)
 ***
+
 ### 环境安装
 - 查看各操作帮助信息
 ```shell
@@ -40,3 +42,4 @@ make test
 - rfskit: 控制rfs等板卡设备的基础库
 - tests: 项目接口自动化测试相关文件
 - ultra_mci.ini: 借助supervisor的自动启动文件，会在`sudo make install`时被拷贝到`/etc/supervisord.d/`下
+****

{nsqdriver-0.2.3 → nsqdriver-0.2.5}/nsqdriver/NS_MCI.py

@@ -336,9 +336,9 @@ class Driver(BaseDriver):
         _string = [f'*********设备{self.addr}开启成功*********']
         for key in keys:
             _string.append(f'{key}: {status.get(key, "nan")}')
-        for i in range(len(status['rfsoc_addr'])):
-            _string.append(f'sub_device{status["rfsoc_addr"][i]}: '
-                           f'{status["ref_clock_lock"][i]}{status["ref_clock_from"][i]}')
+        # for i in range(len(status['rfsoc_addr'])):
+        #     _string.append(f'sub_device{status["rfsoc_addr"][i]}: '
+        #                    f'{status["ref_clock_lock"][i]}{status["ref_clock_from"][i]}')
         print('\n'.join(_string))
 
 

{nsqdriver-0.2.3 → nsqdriver-0.2.5}/nsqdriver/NS_QSYNC.py

@@ -54,8 +54,8 @@ def retry(times):
 
 class Driver(BaseDriver):
     class ScannMode(enum.IntEnum):
-        """
-        QC/QR等被同步设备的发现方式，'local': 本地共享内存扫描， 'remote': 网络udp扫描
+        """!
+        @detail QC/QR等被同步设备的发现方式，'local': 本地共享内存扫描， 'remote': 网络udp扫描
         """
         local = 0
         """local: 本地共享内存扫描
@@ -98,6 +98,8 @@ class Driver(BaseDriver):
         Quantity('ResetTrig', value=None),
         Quantity('Shot', value=1024, ch=1),  # set/get, 运行次数
         Quantity('TrigPeriod', value=200e-6, ch=1),  # set/get, 触发周期
+        Quantity('TrigWidth', value=800e-9, ch=1),  # set/get, 触发周期
+        Quantity('TrigDelay', value=0, ch=1),  # set/get, 触发周期
         Quantity('TrigFrom', value=0, ch=1),  # Trig来源： 0：内部产生；1：外部输入
         Quantity('RefClock', value='out', ch=1),  # 参考时钟选择： ‘out’：外参考时钟；‘in’：内参考时钟
         Quantity('DiscoveryMode', value=ScannMode.local, ch=1),  # QC/QR等被同步设备的发现方式，见DiscoveryMode说明
@@ -107,7 +109,9 @@ class Driver(BaseDriver):
     SystemParameter = {
         'RefClock': 'out',  # 参考时钟选择： ‘out’：外参考时钟；‘in’：内参考时钟
         'TrigFrom': 0,  # Trig来源： 0：内部产生；1：外部输入
-        'TrigPeriod': 200e-6,
+        'TrigPeriod': 200e-6,  # 触发信号重复周期
+        'TrigWidth': 800e-9,  # 触发信号高电平宽度 单位s
+        'TrigDelay': 0,  # 触发信号相对开启通知的延迟
         'DiscoveryMode': ScannMode.local,  # QC/QR等被同步设备的发现方式，见DiscoveryMode说明
     }
 
@@ -119,7 +123,7 @@ class Driver(BaseDriver):
         self.gen_trig_num = 0
         self.addr = addr
 
-        self.param = {'shots': 1024, 'period': 200e-6, 'MixMode': 2}
+        self.param = {'Shot': 1024, 'period': 200e-6, 'MixMode': 2}
         print_debug(f'QSYNC: 实例化成功{addr}')
 
     @property
@@ -138,9 +142,11 @@ class Driver(BaseDriver):
             return set()
 
     def open(self, **kw):
-        """
+        """!
         输入IP打开设备，配置默认超时时间为5秒
         打开设备时配置RFSoC采样时钟，采样时钟以参数定义
+        @param kw:
+        @return:
         """
         # 配置系统初始值
         system_parameter = kw.get('system_parameter', {})
@@ -175,20 +181,30 @@ class Driver(BaseDriver):
         return result
 
     def set(self, name, value=None, channel=1):
-        """
+        """!
         设置设备属性
+        @param name:
+        @param value:
+        @param channel:
+        @return:
         """
         print_debug(f'QSYNC: set操作被调用{name}')
         if name in {'SystemSync', 'ReInit'}:
             self.sync_system()
         elif name == 'TRIG':
             value = self.param['TrigPeriod']
-            data = self.__fmt_qsync_start(self.param['TrigFrom'], value, self.param['Shot'])
+            data = self.__fmt_qsync_start(
+                self.param['TrigFrom'], value, self.param['Shot'],
+                self.param['TrigWidth'], self.param['TrigDelay']
+            )
             self._send_command(data, connect_timeout=2)
             self.gen_trig_num += 1
         elif name == 'GenerateTrig':
             value = self.param['TrigPeriod'] if value is None else value
-            data = self.__fmt_qsync_start(self.param['TrigFrom'], value, self.param['Shot'])
+            data = self.__fmt_qsync_start(
+                self.param['TrigFrom'], value, self.param['Shot'],
+                self.param['TrigWidth'], self.param['TrigDelay']
+            )
             self._send_command(data, connect_timeout=2)
             self.gen_trig_num += 1
         elif name == 'ResetTrig':
@@ -203,8 +219,12 @@ class Driver(BaseDriver):
             self.param[name] = value
 
     def get(self, name, channel=1, value=0):
-        """查询设备属性，获取数据
-
+        """!
+        查询设备属性，获取数据
+        @param name:
+        @param channel:
+        @param value:
+        @return:
         """
         print_debug(f'QSYNC: get操作被调用{name}')
         if name == 'Status':
@@ -250,11 +270,11 @@ class Driver(BaseDriver):
         self._send_command(data)
 
     def _sendto_device(self, cmd_head, timeout=2):
-        """
+        """!
         将指令发送给设备
-
-        :param cmd_head:
-        :return:
+        @param cmd_head:
+        @param timeout:
+        @return:
         """
         cmd_data = self.__fmt_qsync_common(cmd_head)
         devices = list(self.device_set)
@@ -283,11 +303,11 @@ class Driver(BaseDriver):
         return result
 
     def _sendto_qsync(self, cmd_head: int):
-        """
+        """!
         将指令发送给qsync
 
-        :param cmd_head:
-        :return:
+        @param cmd_head:
+        @return:
         """
         cmd_data = self.__fmt_qsync_common(cmd_head)
         if not self._send_command(cmd_data, connect_timeout=2):
@@ -296,12 +316,12 @@ class Driver(BaseDriver):
         return True
 
     def update_firmware(self, file_path, boards=None):
-        """
+        """!
         固件更新
 
-        :param file_path: 固件路径
-        :param boards:
-        :return:
+        @param file_path: 固件路径
+        @param boards:
+        @return:
         """
         import os
         if not os.path.exists(file_path):
@@ -312,12 +332,12 @@ class Driver(BaseDriver):
             print(f'qsync: 固件更新 执行失败')
 
     def _connect(self, addr=None, port=5001, timeout=None):
-        """
+        """!
         获取到指定ip的tcp连接
 
-        :param addr:
-        :param port:
-        :return:
+        @param addr:
+        @param port:
+        @return:
         """
         timeout = self.timeout if timeout is None else timeout
         addr = self.addr if addr is None else addr
@@ -329,15 +349,16 @@ class Driver(BaseDriver):
     @retry(3)
     def _send_command(self, data: Union[str, bytes], wait=0, addr=None, port=5001,
                       check_feedback=True, return_fdk=False, connect_timeout=10):
-        """
+        """!
         发送指定内容到后端
 
-        :param data: 指令内容
-        :param wait: 指令发送完成后，等待一段时间再接收反馈，阻塞式等待
-        :param addr: 后端IP
-        :param port: 后端端口
-        :param 是否解析反馈
-        :return:
+        @param data: 指令内容
+        @param wait: 指令发送完成后，等待一段时间再接收反馈，阻塞式等待
+        @param addr: 后端IP
+        @param port: 后端端口
+        @param check_feedback: 是否解析反馈
+        @param connect_timeout:
+        @return:
         """
         command_bak = data
         try:
@@ -400,15 +421,17 @@ class Driver(BaseDriver):
         return struct.pack('=' + 'I' * len(cmd_pack), *cmd_pack)
 
     @lru_cache(maxsize=32)
-    def __fmt_qsync_start(self, src, period, shots):
+    def __fmt_qsync_start(self, src, period, shots, width, delay):
         cmd_pack = (
             0x5F5F5F5F,
             0x41000001,
             0x00000000,
-            28,
+            36,
             int(src),
             int(period * 1e9) & 0xFFFFFFFF,
-            int(shots)
+            int(shots),
+            int(width * 1e9) & 0xFFFFFFFF,
+            int(delay * 1e9) & 0xFFFFFFFF
         )
 
         return struct.pack('=' + 'I' * len(cmd_pack), *cmd_pack)
@@ -433,10 +456,12 @@ class Driver(BaseDriver):
         self.set('TrigPeriod', 1 / rate)
         self.set('GenerateTrig')
 
-    def BurstMode_init(self, count=2048, delay=200e-6, period=200e-6, **kwds):
+    def BurstMode_init(self, count=2048, delay=200e-6, period=200e-6, source=0, **kwds):
         self.set('ResetTrig')
         self.set('Shot', count)
         self.set('TrigPeriod', period)
+        self.set('TrigDelay', delay)
+        self.set('TrigFrom', source)
 
     def startGun(self):
         self.Trigger_singleshot()
@@ -479,8 +504,8 @@ def do_scanning():
 
 
 class DeviceCmdHandle:
-    """
-    封装与QC/QR设备间的交互
+    """!
+    @brief 封装与QC/QR设备间的交互
     """
     error_map = {b'\x1a\x00\x001': {1: '指令Resync执行失败',
                                     2: 'REFCLK not Detected',
@@ -541,17 +566,17 @@ class DeviceCmdHandle:
     @classmethod
     def send_command(cls, data: Union[str, bytes], wait=0, addr=None, port=5001,
                      check_feedback=True, return_fdk=False, connect_timeout=None):
-        """
+        """!
         发送指定内容到后端
 
-        :param data: 指令内容
-        :param wait: 指令发送完成后，等待一段时间再接收反馈，阻塞式等待
-        :param addr: 后端IP
-        :param port: 后端端口
-        :param check_feedback:
-        :param return_fdk:
-        :param connect_timeout:
-        :return:
+        @param data: 指令内容
+        @param wait: 指令发送完成后，等待一段时间再接收反馈，阻塞式等待
+        @param addr: 后端IP
+        @param port: 后端端口
+        @param check_feedback:
+        @param return_fdk:
+        @param connect_timeout:
+        @return:
         """
         command_bak = data
         try:

{nsqdriver-0.2.3 → nsqdriver-0.2.5}/nsqdriver/__init__.py

@@ -1,7 +1,7 @@
 from .NS_MCI import Driver as MCIDriver
 from .NS_QSYNC import Driver as QSYNCDriver
 
-version_pack = (0, 2, 3)
+version_pack = (0, 2, 5)
 
 __version__ = '.'.join(str(_) for _ in version_pack)
 __all__ = ['MCIDriver', 'QSYNCDriver', '__version__']

nsqdriver-0.2.5/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.2.3 → nsqdriver-0.2.5}/nsqdriver.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nsqdriver
-Version: 0.2.3
+Version: 0.2.5
 Summary: Naishu Q series quantum measurement and control equipment driver interface
 Home-page: https://g2hoyqcmh4.feishu.cn/wiki/wikcnzvyMd82DLZUe2NsI6HxsFc
 Author: Naishu Technology

{nsqdriver-0.2.3 → nsqdriver-0.2.5}/nsqdriver.egg-info/SOURCES.txt

@@ -11,4 +11,13 @@ nsqdriver.egg-info/dependency_links.txt
 nsqdriver.egg-info/requires.txt
 nsqdriver.egg-info/top_level.txt
 nsqdriver/wrapper/AWG_ADC.py
-nsqdriver/wrapper/__init__.py
+nsqdriver/wrapper/ND_NSMCI.py
+nsqdriver/wrapper/__init__.py
+tests/test_cy_gen_wave.py
+tests/test_demod_speed.py
+tests/test_driver_info_memory.py
+tests/test_init_device.py
+tests/test_mixer_simulator.py
+tests/test_param_memory.py
+tests/test_rfskit_base.py
+tests/test_rpc_parser.py

nsqdriver-0.2.5/tests/test_cy_gen_wave.py

@@ -0,0 +1,148 @@
+from functools import wraps
+import platform
+from concurrent.futures import ProcessPoolExecutor
+import numpy as np
+import pytest
+from waveforms import *
+from time import time
+
+from cython_lib.lib_gen_waveform.gen_waveform import gen_wave
+
+sample_rate = 4e9
+width = 20e-9
+time_line = np.linspace(0, width * 100, int(width * 100 * sample_rate))
+waves = {
+    'poly': poly([1, -1 / 2, 1 / 6, -1 / 12]),
+    'cos': cos(2 * pi * 5.2e9),
+    'sin': sin(2 * pi * 5.2e9),
+    'gaussian': gaussian(width) >> (width * 2),
+    'sinc': sinc(6e8),
+    'square': square(width) >> (width * 2),
+    'cosPulse': cosPulse(width) >> (width * 2),
+    'chirp_linear': chirp(1e9, 1.5e9, width * 10, type='linear'),
+    'chirp_exponential': chirp(1e9, 1.5e9, width * 10, type='exponential'),
+    'chirp_hyperbolic': chirp(1e9, 1.5e9, width * 10, type='hyperbolic'),
+    'cos*gaussian': cos(2 * pi * 5.2e9) * gaussian(width) >> (width * 2),
+    'cos*cosPulse': cos(2 * pi * 5.2e9) * cosPulse(width) >> (width * 2),
+    'gaussian_with_window': (gaussian(10) >> width*2) + square(width, edge=5, type='linear') * cos(2 * pi * 5.2e9),
+}
+
+
+def gen(_wave, _width, rate):
+    line = np.arange(0, _width, 1 / rate)
+    gen_wave(_wave, line)
+
+
+def gen_numpy(_wave, _width, rate):
+    line = np.arange(0, _width, 1 / rate)
+    _wave(line)
+
+
+class TestCyGenWave:
+    @pytest.mark.skipif(platform.system() == 'Windows', reason='gen_wave暂不支持windows')
+    @pytest.mark.parametrize('wave', [pytest.param(j, id=f'Wave<{i}>') for i, j in waves.items()])
+    def test_waveform_close(self, wave: Waveform):
+        """
+        判断生成的float64数据是否全部接近
+        """
+        wave_numpy = wave(time_line)
+        wave_cython = gen_wave(wave, time_line)
+        assert np.allclose(wave_numpy, wave_cython)
+
+    @pytest.mark.skipif(platform.system() == 'Windows', reason='gen_wave暂不支持windows')
+    @pytest.mark.parametrize('wave', [pytest.param(j, id=f'Wave<{i}>') for i, j in waves.items()])
+    def test_waveform_equal(self, wave):
+        """
+        判断生成的数据转为int16后是否完全相等
+        """
+        wave_numpy = wave(time_line)
+        wave_cython = gen_wave(wave, time_line)
+        assert ((wave_numpy * (2 ** 15 - 1)).astype(np.int16) == (wave_cython * (2 ** 15 - 1)).astype(np.int16)).all()
+
+    @pytest.mark.skipif(platform.system() == 'Windows', reason='gen_wave暂不支持windows')
+    def test_pulse_speed(self):
+        """
+        pulse信号生成速度测试
+        """
+        sample_rate = 6e9
+        width = 30e-9
+        width_all = 100e-6
+        frq = 4200e6
+        chnl_num = 24
+
+        wave_lo = cos(2 * pi * frq)
+        wave_30 = [(gaussian(width) >> (width / 2)) * wave_lo for i in range(chnl_num)]
+        for wave in wave_30:
+            wave.start = 0
+            wave.stop = width
+        wave_100 = [zero() for i in range(chnl_num)]
+        for index, wave in enumerate(wave_100):
+            for i in range(int(300)):
+                wave += (gaussian(width) >> (width * 2 * i + width / 2)) * wave_lo
+            wave.start = 0
+            wave.stop = width_all
+            wave_100[index] = wave
+
+        st = time()
+        for i in range(10):
+            for wave in wave_30:
+                line = np.arange(0, width_all, 1 / sample_rate)
+                wave_numpy = wave_lo(line)
+        print(f'\n{chnl_num}通道, numpy长波形生成耗时: {(time() - st) / 10}')
+
+        st = time()
+        for i in range(10):
+            for wave in wave_30:
+                line = np.arange(0, width_all, 1 / sample_rate)
+                wave_cython = gen_wave(wave_lo, line)
+        print(f'{chnl_num}通道, cython长波形生成耗时: {(time() - st) / 10}')
+
+        assert np.allclose(wave_numpy, wave_cython)
+
+        pool = ProcessPoolExecutor(max_workers=6)
+        st = time()
+        for i in range(5):
+            futures = [pool.submit(gen_numpy, wave_lo, width_all, sample_rate) for wave in wave_30]
+            [_.result() for _ in futures]
+        print(f'{chnl_num}通道, 进程池numpy长波形生成耗时: {(time() - st) / 5}')
+        pool.shutdown(wait=True)
+
+        pool = ProcessPoolExecutor(max_workers=6)
+        st = time()
+        for i in range(5):
+            futures = [pool.submit(gen, wave_lo, width_all, sample_rate) for wave in wave_30]
+            [_.result() for _ in futures]
+        print(f'{chnl_num}通道, 进程池cython长波形生成耗时: {(time() - st) / 5}')
+        pool.shutdown(wait=True)
+
+        st = time()
+        for i in range(100):
+            for wave in wave_30:
+                line = np.arange(0, width_all, 1/sample_rate)
+                wave_numpy = wave(line)
+        print(f'\n{chnl_num}通道, numpy简单波形生成耗时: {(time() - st) / 100}')
+
+        st = time()
+        for i in range(100):
+            for wave in wave_30:
+                line = np.arange(0, width_all, 1 / sample_rate)
+                wave_cython = gen_wave(wave, line)
+        print(f'{chnl_num}通道, cython简单波形生成耗时: {(time() - st) / 100}')
+
+        assert np.allclose(wave_numpy, wave_cython)
+
+        st = time()
+        for i in range(5):
+            for wave in wave_100:
+                line = np.arange(0, width_all, 1 / sample_rate)
+                wave_numpy = wave(line)
+        print(f'{chnl_num}通道, numpy复杂波形生成耗时: {(time() - st) / 10}')
+
+        st = time()
+        for i in range(5):
+            for wave in wave_100:
+                line = np.arange(0, width_all, 1 / sample_rate)
+                wave_cython = gen_wave(wave, line)
+        print(f'{chnl_num}通道, cython复杂波形生成耗时: {(time() - st) / 5}')
+
+        assert np.allclose(wave_numpy, wave_cython)

nsqdriver-0.2.5/tests/test_demod_speed.py

@@ -0,0 +1,230 @@
+from functools import wraps
+import numpy as np
+import pytest
+import torch
+# import matplotlib.pyplot as plt
+from waveforms import *
+from time import time
+from .conftest import skip_demod_speed_test, skip_numpy_demod_test
+
+from backend.svqbit import coff_para, demodMatrix, demodTorch, demodTorch_no_complex
+
+# import os
+#
+# cpu_num = 6 # 这里设置成你想运行的CPU个数
+# os.environ ['OMP_NUM_THREADS'] = str(cpu_num)
+# os.environ ['OPENBLAS_NUM_THREADS'] = str(cpu_num)
+# os.environ ['MKL_NUM_THREADS'] = str(cpu_num)
+# os.environ ['VECLIB_MAXIMUM_THREADS'] = str(cpu_num)
+# os.environ ['NUMEXPR_NUM_THREADS'] = str(cpu_num)
+# torch.set_num_threads(cpu_num)
+torch.set_grad_enabled(False)
+
+
+def no_tensor_grad(func):
+    @wraps(func)
+    def dec(*args, **kwargs):
+        with torch.no_grad():
+            return func(*args, **kwargs)
+
+    return dec
+
+
+params = []
+for chnl in [1, 6, 12]:
+    for frq in [6, 12, 24]:
+        for shots in [32, 64, 128, 256, 512, 1024]:
+            params.append(pytest.param(chnl, frq, shots, id=f'Param<{chnl, frq, shots}>'))
+
+
+def test_pytorch_cuda_enabled():
+    print(torch.__config__.show())
+    print(torch.__config__.parallel_info())
+    print(f'\n pytorch_cuda_enable: {torch.cuda.is_available()}')
+    assert True
+
+
+@pytest.mark.skipif(True, reason='两边算出来的值有差别')
+def test_algorithm_equal():
+    lo, freq = 4.5e9, [i*1e6 for i in range(1, 9)]
+    sigs = []
+    for i in range(8):
+        wave = cos(2 * np.pi * (lo+freq[i]))
+        wave.start, wave.stop = 0, 4e-6
+        noise = 0.01*np.random.random((1024, 16000))
+        sig = np.empty((1024, 16000))
+        _sig = wave.sample(4e9)
+        for j in range(1024):
+            sig[j] = _sig
+        sig += noise
+        sig = (2 ** 15 - 1) * sig
+        sigs.append(sig)
+    sigs = np.array(sigs, dtype=np.int16)
+
+    tm = np.linspace(0, 4e-6, 16000)
+    coff = [coff_para(tm, lo).reshape(16000, 1) for _ in range(8)]
+    coff = np.array(coff)
+
+    numpy_res = np.zeros((8, 1024, 1), dtype='complex64')
+    for i in range(8):
+        numpy_res[i] = demodMatrix(sigs[i], coff[i])
+
+    torch_res = torch.zeros((8, 1024, 1), dtype=torch.complex64)
+    torch_sigs = torch.tensor(sigs).to(torch.complex64)
+    torch_coff = torch.tensor(coff).to(torch.complex64)
+    for i in range(4):
+        demodTorch(torch_sigs[:, i*256:(i+1)*256, :], torch_coff, out=torch_res[:, i*256:(i+1)*256, :])
+
+    assert np.allclose(numpy_res, torch_res.numpy())
+    assert (numpy_res == torch_res).all()
+
+
+@pytest.mark.skipif(skip_demod_speed_test, reason='跳过硬解速度测试，过于耗时')
+@pytest.mark.parametrize('chnl_num, frq_num, shots', params)
+def test_pytorch_demodulator(chnl_num, frq_num, shots):
+    sample_rate = 4e9
+    width = 4e-6
+
+    freqlist = [[4550e6 + j * 300e6 for j in range(frq_num)] for i in range(chnl_num)]
+    cofflist = {i: [] for i in range(chnl_num)}
+
+    wav_readout = [zero() for i in range(chnl_num)]
+    for i in range(chnl_num):
+        for j in range(len(freqlist[i])):
+            wav_readout[i] = wav_readout[i] + cos(2 * np.pi * freqlist[i][j]) * (square(width) >> width / 2)
+            # wav_readout[i] = wav_readout[i] + (square(width) >> width/2+1e-6)
+        wav_readout[i] = wav_readout[i] / frq_num
+        wav_readout[i].start = 0
+        wav_readout[i].stop = width
+        wav_readout[i] = (2 ** 15 - 1) * wav_readout[i].sample(sample_rate).reshape((1, round(width * sample_rate)))
+        wav_readout[i] = np.vstack([wav_readout[i] for _ in range(shots)])
+    wav_readout = torch.tensor(np.array(wav_readout, dtype='int16'), dtype=torch.int16).to(torch.complex64)
+
+    tm = np.linspace(0, width, round(width * sample_rate))
+    for chnl in range(chnl_num):
+        _freqlist = freqlist[chnl]
+        cofflist[chnl] = np.empty((len(_freqlist), round(width * sample_rate))).astype(complex)
+        for i in range(len(_freqlist)):
+            cofflist[chnl][i] = coff_para(tm, _freqlist[i], 0)
+        cofflist[chnl] = cofflist[chnl].T
+    cofflist = torch.tensor(np.array([i for i in cofflist.values()]), dtype=torch.complex64)
+
+    st = time()
+    threads = []
+    # for i in range(2):
+    #     _thread = threading.Thread(target=demodTorch, args=(wav_readout, cofflist), daemon=True)
+    #     threads.append(_thread)
+    # for i in threads:
+    #     i.start()
+    # for i in threads:
+    #     i.join()
+
+    for i in range(5):
+        demodTorch(wav_readout, cofflist)
+    print(f'----{chnl_num}通道, {frq_num}频点, {shots}shots, 单个shots硬解耗时: {(time() - st) / 5 / shots * 1e6}-{200}μs')
+
+
+@pytest.mark.skipif(skip_demod_speed_test, reason='跳过硬解速度测试，过于耗时')
+@pytest.mark.parametrize('chnl_num, frq_num, shots', params)
+def test_pytorch_no_complex(chnl_num, frq_num, shots):
+    """
+    下变频速度测试，非复数运算版
+    """
+    sample_rate = 4e9
+    width = 4e-6
+    # chnl_num = 1
+    # frq_num = 1
+    # shots = 1
+
+    freqlist = [[4550e6 + j * 300e6 for j in range(frq_num)] for i in range(chnl_num)]
+    cofflist = {i: [] for i in range(chnl_num)}
+
+    wav_readout = [zero() for i in range(chnl_num)]
+    for i in range(chnl_num):
+        for j in range(len(freqlist[i])):
+            wav_readout[i] = wav_readout[i] + cos(2 * np.pi * freqlist[i][j]) * (square(width) >> width / 2)
+            # wav_readout[i] = wav_readout[i] + (square(width) >> width/2+1e-6)
+        wav_readout[i] = wav_readout[i] / frq_num
+        wav_readout[i].start = 0
+        wav_readout[i].stop = width
+        wav_readout[i] = (2 ** 15 - 1) * wav_readout[i].sample(sample_rate).reshape((1, round(width * sample_rate)))
+        wav_readout[i] = np.vstack([wav_readout[i] for _ in range(shots)])
+    wav_readout = torch.tensor(np.array(wav_readout, dtype='int16'), dtype=torch.float32)
+
+    tm = np.linspace(0, width, round(width * sample_rate))
+    for chnl in range(chnl_num):
+        _freqlist = freqlist[chnl]
+        cofflist[chnl] = np.empty((len(_freqlist), round(width * sample_rate))).astype(complex)
+        for i in range(len(_freqlist)):
+            cofflist[chnl][i] = coff_para(tm, _freqlist[i], 0)
+        cofflist[chnl] = cofflist[chnl].T
+    cofflist = torch.tensor(np.array([i for i in cofflist.values()]), dtype=torch.complex64)
+    cofflist = [cofflist.real.to(torch.float32), cofflist.imag.to(torch.float32)]
+
+    st = time()
+    threads = []
+    # for i in range(10):
+    #     _thread = threading.Thread(target=demodTorch, args=(wav_readout, cofflist), daemon=True)
+    #     threads.append(_thread)
+    # for i in threads:
+    #     i.start()
+    # for i in threads:
+    #     i.join()
+
+    for i in range(5):
+        demodTorch_no_complex(wav_readout, cofflist, [round(width * sample_rate)]*chnl_num)
+    print(f'----{chnl_num}通道, {frq_num}频点, {shots}shots, 单个shots硬解耗时: {(time() - st) / 5 / shots * 1e6}-{200}μs')
+
+
+@pytest.mark.skipif(skip_demod_speed_test, reason='跳过硬解速度测试')
+@pytest.mark.skipif(skip_numpy_demod_test, reason='跳过numpy硬解速度测试')
+@pytest.mark.parametrize('chnl_num, frq_num, shots', params)
+def test_numpy_demodulator(chnl_num, frq_num, shots):
+    """
+    numpy库硬解测试
+
+    :param chnl_num:
+    :param frq_num:
+    :param shots:
+    :return:
+    """
+    sample_rate = 4e9
+    width = 4e-6
+    # chnl_num = 1
+    # frq_num = 1
+    # shots = 1
+
+    freqlist = [[4550e6 + j * 300e6 for j in range(frq_num)] for i in range(chnl_num)]
+    cofflist = {i: [] for i in range(chnl_num)}
+
+    wav_readout = [zero() for i in range(chnl_num)]
+    for i in range(chnl_num):
+        for j in range(len(freqlist[i])):
+            wav_readout[i] = wav_readout[i] + cos(2 * np.pi * freqlist[i][j]) * (square(width) >> width / 2)
+            # wav_readout[i] = wav_readout[i] + (square(width) >> width/2+1e-6)
+        wav_readout[i] = wav_readout[i] / frq_num
+        wav_readout[i].start = 0
+        wav_readout[i].stop = width
+        wav_readout[i] = (2 ** 15 - 1) * wav_readout[i].sample(sample_rate).reshape((1, round(width * sample_rate)))
+        wav_readout[i] = np.vstack([wav_readout[i] for _ in range(shots)])
+    wav_readout = np.array(wav_readout, dtype='int16')
+
+    tm = np.linspace(0, width, round(width * sample_rate))
+    for chnl in range(chnl_num):
+        _freqlist = freqlist[chnl]
+        cofflist[chnl] = np.empty((len(_freqlist), round(width * sample_rate))).astype(complex)
+        for i in range(len(_freqlist)):
+            cofflist[chnl][i] = coff_para(tm, _freqlist[i], 0)
+        cofflist[chnl] = cofflist[chnl].T
+    cofflist = np.array([i for i in cofflist.values()], dtype=complex)
+
+    st = time()
+    threads = []
+
+    def demod(wave, coff):
+        for i in range(chnl_num):
+            demodMatrix(wave[i], coff[i])
+
+    for i in range(2):
+        demod(wav_readout, cofflist)
+    print(f'----{chnl_num}通道, {frq_num}频点, {shots}shots, 单个shots硬解耗时: {(time() - st) / 2 / (shots) * 1e6}-{200}μs')

nsqdriver-0.2.5/tests/test_driver_info_memory.py

@@ -0,0 +1,37 @@
+import pytest
+import multiprocessing
+
+from nsqdriver.NS_MCI import SHARED_DEVICE_MEM as MCI_MEM
+from nsqdriver.NS_QSYNC import SHARED_DEVICE_MEM as QSYNC_MEM
+
+DEVICES_IP = ['192.168.1.205', '192.168.1.206', '192.168.1.207', '192.168.1.208']
+
+
+def test_driver_info_shared():
+    """
+    测试进程内确实可以共享info信息
+
+    :return:
+    """
+    for ip in DEVICES_IP:
+        MCI_MEM.ip = ip
+    assert set(QSYNC_MEM.ip) == set(DEVICES_IP)
+
+
+def other_process():
+    for ip in DEVICES_IP:
+        MCI_MEM.ip = ip
+
+
+def test_shared_to_other_process():
+    """
+    测试跨进程增加信息
+
+    :return:
+    """
+    MCI_MEM.clear_ip()
+    assert QSYNC_MEM.ip == []
+    process = multiprocessing.Process(target=other_process, daemon=True)
+    process.start()
+    process.join(2)
+    assert set(QSYNC_MEM.ip) == set(DEVICES_IP)

nsqdriver-0.2.5/tests/test_init_device.py

@@ -0,0 +1,5 @@
+from cython_lib.lib_init_device.init_device import get_board_info
+
+
+def test_print_board_info():
+    print(get_board_info())

nsqdriver-0.2.5/tests/test_mixer_simulator.py

@@ -0,0 +1,3 @@
+class TestUpMixer:
+    def test_conversion(self):
+        pass

nsqdriver-0.2.5/tests/test_param_memory.py

@@ -0,0 +1,101 @@
+import pytest
+import numpy as np
+import waveforms
+
+from rfskit.config import dumps_dict
+from backend.param_memory import ParamMemory, global_param_memory, AttributeWithMemory, BoardProperty
+
+
+class ExampleClass(AttributeWithMemory):
+    def __init__(self):
+        self.attr_a = 'a'
+        self.attr_b = 156
+
+
+EXAMPLE_OBJ = ExampleClass()
+
+
+class TestParamMemory:
+    """
+    测试ParamMemory
+    """
+
+    def test_is_singleton_memory(self):
+        """
+        测试全局只有一个memory
+        """
+        print(f'\n{self.test_is_singleton_memory.__doc__}')
+        assert ParamMemory() is global_param_memory
+
+    @pytest.mark.parametrize('name, value',
+                             [pytest.param('save_list', [1, 2, 3], id='Type<list>'),
+                              pytest.param('save_waveforms', waveforms.cos(10), id='Type<waveforms>')])
+    def test_set_param(self, name, value):
+        """
+        测试向memory里设置和取出参数
+        """
+        # print(f'\n{self.test_set_param.__doc__} {name}-{value}')
+        setattr(global_param_memory, name, value)
+        assert getattr(global_param_memory, name) == value
+
+    def test_like_obj_attr(self):
+        _value = np.array([1, 2, 3])
+        global_param_memory.data = _value
+        assert (global_param_memory.data == _value).all()
+        assert 'data' in global_param_memory._memory
+
+    def test_memory_like_dict(self):
+        _value = np.array([1, 2, 3])
+        global_param_memory['data_dict'] = _value
+        assert (global_param_memory['data_dict'] == _value).all()
+        assert 'data_dict' in global_param_memory['_memory']
+
+    def test_debug_param(self):
+        debug_name = 'debug_test'
+        assert global_param_memory.get_debug_value(debug_name) is None
+        # global_param_memory.debug_params.add(debug_name)
+        global_param_memory.add_debug_param(debug_name)
+        for i in range(10):
+            global_param_memory.debug_test = i
+
+        # print(f'\n{global_param_memory.debug_test}')
+        assert global_param_memory.debug_test == 9
+        assert list(global_param_memory.get_debug_value(debug_name).values()) == list(range(10))
+        print(f"\n{dumps_dict(global_param_memory.get_debug_value(debug_name))}")
+        # clear_debug_log
+        global_param_memory.clear_debug_log(debug_name)
+        assert global_param_memory.get_debug_value(debug_name) == {}
+
+    def test_print_memory(self):
+        print(f'\n keys: {global_param_memory.show_keys()}')
+        print(f'\n repr: {repr(global_param_memory)}')
+        print(f'\n str: {global_param_memory}')
+
+
+class TestAttributeWithMemory:
+    def test_auto_memory_name(self):
+        assert getattr(EXAMPLE_OBJ, 'memory_name', None) == EXAMPLE_OBJ.__class__.__name__
+
+    def test_remember_obj_attr(self):
+        assert global_param_memory[EXAMPLE_OBJ.get_memory_name('attr_a')] == EXAMPLE_OBJ.attr_a
+        assert global_param_memory[EXAMPLE_OBJ.get_memory_name('attr_b')] == EXAMPLE_OBJ.attr_b
+
+
+class Board(AttributeWithMemory):
+    aa = BoardProperty('aa_p', 10)
+
+    def __init__(self, aa):
+        self.aa = aa
+
+
+class TestBoardProperty:
+    def test_set_prop(self):
+        a = Board(3)
+        b = Board(6)
+        c = Board({'aa_p': 8})
+        assert a.aa == 3 and b.aa == 6 and c.aa == 8
+
+    def test_immutable_prop(self):
+        a = Board({'!aa_p': 9})
+        a.aa = 15
+        assert a.aa == 9

nsqdriver-0.2.5/tests/test_rfskit_base.py

@@ -0,0 +1,36 @@
+import pytest
+import time
+
+from .conftest import FakeTCPHandler, skip_rfskit_test
+from rfskit import RFSKit
+from rfskit.interface import CommandTCPInterface, DataTCPInterface
+
+
+class TestRFSKit:
+    @pytest.mark.skipif(skip_rfskit_test,
+                        reason='越过rfskit测试')
+    def test_init_rfskit(self, fake_cmd_server):
+        CommandTCPInterface._target_id = '127.0.0.1'
+        kit = RFSKit(auto_load_icd=True,
+                     auto_write_file=False,
+                     cmd_interface=CommandTCPInterface,
+                     data_interface=DataTCPInterface)
+        connected = kit.start_command('127.0.0.1')
+
+        assert isinstance(kit, RFSKit)
+        assert connected
+        assert connected == kit._connected
+
+    @pytest.mark.skipif(skip_rfskit_test,
+                        reason='越过rfskit测试')
+    @pytest.mark.skipif(not FakeTCPHandler.finished,
+                        reason='处理函数未完成')
+    def test_send_tcp_command(self, fake_cmd_server):
+        time.sleep(1)
+        CommandTCPInterface._target_id = '127.0.0.1'
+        kit = RFSKit(auto_load_icd=True,
+                     auto_write_file=False,
+                     cmd_interface=CommandTCPInterface,
+                     data_interface=DataTCPInterface)
+        kit.start_command('127.0.0.1')
+        assert kit.execute_command('内部PRF产生')

nsqdriver-0.2.5/tests/test_rpc_parser.py

@@ -0,0 +1,102 @@
+import pytest
+from copy import copy
+import numpy as np
+import waveforms
+
+from nsqdriver.NS_MCI import RPCValueParser
+from rfskit.config import dumps_dict
+
+
+class TestRPCValueParser:
+    """
+    测试RPCValueParser.dump与RPCValueParser.load的完备性
+    """
+    @pytest.mark.parametrize('value',
+                             [pytest.param(['tom', 1, 2, [1, 2]], id='Type<list>'),
+                              pytest.param(np.array([1], dtype=np.float64)[0], id='Type<np.float64>'),
+                              pytest.param(np.array([1], dtype=np.int32)[0], id='Type<np.int32>'),
+                              pytest.param(15.34, id='Type<num>'),
+                              pytest.param(15 + 1j, id='Type<complex>'),
+                              pytest.param(waveforms.cos(100), id='Type<waveforms.Waveform>')])
+    def test_parser_common(self, value):
+        """
+        通用测试
+
+        :param value:
+        :return:
+        """
+        data = RPCValueParser.dump(value)
+        _res = RPCValueParser.load(data)
+        assert value == _res
+
+    def test_parser_ndarray(self):
+        """
+        测试ndarray
+
+        :return:
+        """
+        # 普通array
+        _value = np.arange(100).reshape((10, 10))
+        data = RPCValueParser.dump(_value)
+        _res = RPCValueParser.load(data)
+        assert _value.dtype == _res.dtype
+        assert (_value == _res).all()
+
+        # 复数array
+        _value = np.arange(100).reshape((10, 10)).astype(complex)
+        data = RPCValueParser.dump(_value)
+        _res = RPCValueParser.load(data)
+        assert _value.dtype == _res.dtype
+        assert (_value == _res).all()
+
+    def test_parser_tuple(self):
+        """
+        测试元组
+
+        :return:
+        """
+        _value = (1, 2, '2')
+        data = RPCValueParser.dump(_value)
+        _res = RPCValueParser.load(data)
+
+        assert _value == tuple(_res)
+
+    def test_parser_nested(self):
+        """
+        多层嵌套测试
+
+        :return:
+        """
+        _list = [1, 2, 3]
+        _tuple = (4, 5, 6)
+        _ndarray = np.array([6, 7, 8])
+        _list_tuple = copy(_list)
+        _list_tuple.append(copy(_tuple))
+        _waveform = waveforms.sinc(10)
+
+        _value = [_list, _tuple, _ndarray, _list_tuple, _waveform]
+        data = RPCValueParser.dump(_value)
+        _res = RPCValueParser.load(data)
+
+        assert _list == _res[0]
+        assert _tuple == tuple(_res[1])
+        assert (_ndarray == _res[2]).all()
+        assert _list_tuple[:len(_list)] == _res[3][:len(_list)]
+        assert _list_tuple[len(_list)] == tuple(_res[3][len(_list)])
+        assert _waveform == _res[4]
+
+
+@pytest.mark.parametrize('value',
+                         [pytest.param({}, id='Type<empty>'),
+                          pytest.param({0: ['34', 'list', {1: 1}]}, id='Type<list>'),
+                          pytest.param({'array': np.arange(10000)}, id='Type<np.float64>'),
+                          pytest.param({'np.int32': np.array([1], dtype=np.int32)[0]}, id='Type<np.int32>'),
+                          pytest.param({'num': 15.34}, id='Type<num>'),
+                          pytest.param({'complex': 15 + 1j}, id='Type<complex>'),
+                          pytest.param({'waveform': waveforms.cos(100)}, id='Type<waveforms.Waveform>'),
+                          pytest.param({'collection': {1, 2, 3}}, id='Type<collection>'),
+                          pytest.param({'dict': {'num': 123.34345, 'array': np.arange(10000)}}, id='Type<nested>')])
+def test_dumps_dict(value):
+    data = dumps_dict(value)
+    print('\n'+data)
+    assert isinstance(data, str)