nsqdriver 0.12.10__cp38-cp38-win_amd64.whl → 0.12.12__cp38-cp38-win_amd64.whl

nsqdriver/NS_DDS_v3.py

@@ -1,8 +1,9 @@
 import copy
 from enum import Enum
+from math import ceil
 from collections import namedtuple
-from waveforms import Waveform, wave_eval
-from waveforms.math.signal import getFTMatrix, shift
+from waveforms import Waveform, wave_eval, WaveVStack
+from waveforms.waveform import _zero
 import nsqdriver.nswave as nw
 
 import numpy as np
@@ -43,15 +44,30 @@ def program_cap(param: nw.Var):
     nw.wait_for_trigger()
     i: nw.Var
     # param: [[100e-9, 1e-6], [200e-9, 1e-6]]
+    # nw.wait(150e-9)
     for i in param:
         nw.wait(i[0])
-        nw.capture(i[1], i[2], i[3])
+        nw.capture(i[1], 0, 0)
 
 
-ProbeSegment = namedtuple('ProbeSegment', ['start', 'stop', 'freq'])
+@nw.kernel
+def program_da(p: nw.Var):
+    i: nw.Var
+    e: nw.Var
+    nw.init_frame(0, 0)
+    nw.wait_for_trigger()
+    # nw.reset_frame()
+    for i in p:
+        nw.wait(i[0])
+        e = nw.ins_envelope(i[1])
+        nw.play_wave(e, 1, 0, 0)
 
 
-CaptureCmd = namedtuple('CaptureCmd', ['start', 'ad_duration', 'delay', 'da_duration', 'freqs'])
+ProbeSegment = namedtuple('ProbeSegment', ['start', 'stop', 'freq', 'idx'])
+
+CaptureCmd = namedtuple('CaptureCmd', [
+    'start', 'ad_duration', 'delay', 'da_duration', 'freqs', 'delays', 'idx_list'
+])
 
 
 class DemodulateMode(str, Enum):
@@ -59,102 +75,6 @@ class DemodulateMode(str, Enum):
     COMPLEX_SEQ = 'complex_seq'
 
 
-def get_coef(coef_info, sampleRate):
-    start, stop = coef_info['start'], coef_info['stop']
-    numberOfPoints = int(
-        (stop - start) * sampleRate)
-    if numberOfPoints % 64 != 0:
-        numberOfPoints = numberOfPoints + 64 - numberOfPoints % 64
-    t = np.arange(numberOfPoints) / sampleRate + start
-
-    fList = []
-    wList = []
-    phases = []
-
-    for kw in coef_info['wList']:
-        Delta, t0, weight, w, phase = kw['Delta'], kw['t0'], kw['weight'], kw['w'], kw['phase']
-        fList.append(Delta)
-
-        if w is not None:
-            w = np.zeros(numberOfPoints, dtype=complex)
-            w[:len(w)] = w
-            w = shift(w, t0 - start)
-            phases.append(np.mod(phase + 2 * np.pi * Delta * start, 2 * np.pi))
-        else:
-            weight = weight
-            if isinstance(weight, np.ndarray):
-                pass
-            else:
-                if isinstance(weight, str):
-                    fun = wave_eval(weight) >> t0
-                elif isinstance(weight, Waveform):
-                    fun = weight >> t0
-                else:
-                    raise TypeError(f'Unsupported type {weight}')
-                weight = fun(t)
-            phase += 2 * np.pi * Delta * start
-            w = getFTMatrix([Delta],
-                            numberOfPoints,
-                            phaseList=[phase],
-                            weight=weight,
-                            sampleRate=sampleRate)[:, 0]
-            phases.append(np.mod(phase, 2 * np.pi))
-        wList.append(w)
-    return np.asarray(wList), fList, numberOfPoints, phases, round((stop - t0) * sampleRate), t
-
-
-def granularity4ns(delay):
-    # 4ns取整
-    out_delay = round(
-        delay // 4e-9 * 4e-9, 10
-    )
-    return out_delay
-
-
-def generate_para(device, ch, coef_info):
-    global RES_MAP
-    global PROGRAME_PARA
-    RES_MAP = []
-    PROGRAME_PARA = []
-
-    res_coef = get_coef(coef_info, 4e9)
-    da_ad_delay = 150e-9  # ad相对于da的延迟
-    ad_start = []
-    freq_map = []
-
-    for num, (orig, i) in enumerate(zip(coef_info["wList"], res_coef[0])):
-        RES_MAP.append([None, None])  # 第一个字段标记第几个频点，第二个字段标记第几次采集
-        if orig['Delta'] not in freq_map:
-            # Delta 字段是解模频点
-            # 新增加了频点
-            freq_map.append(orig['Delta'])
-        RES_MAP[-1][0] = freq_map.index(orig['Delta'])
-
-        # 5.43这个频率点包含了第
-        ad_line = res_coef[-1][np.nonzero(i)]
-        ad_width = granularity4ns(ad_line[-1] - ad_line[0] + 0.25e-9)
-        da_width = ad_width  # 设置播放时长=采样时长
-        if orig["t0"] not in ad_start:
-            # 这个采集的起始点以前没配置过
-            PROGRAME_PARA.append([orig["t0"], ad_width, da_ad_delay, da_width])
-            ad_start.append(orig["t0"])
-        # else:
-        #     # 这个采集的起点以前配置过
-        #     cap_num += 1
-        # cap_map[num] = [cap_num, ]
-        RES_MAP[-1][1] = len(ad_start) - 1  # len(ad_start) - 1 表明了当前是第几次采集
-    # print(programe_para, freq_map)
-    device.set("Program", program_cap(PROGRAME_PARA), ch)
-    device.set("FreqList", freq_map, ch)
-
-
-def get_coef_res(iq_res):
-    res = []
-    for (freq_num, cap_num) in RES_MAP:
-        res.append(iq_res[freq_num][cap_num::len(PROGRAME_PARA)])
-    return res
-
-
 class Driver(BaseDriver):
     CHs = list(range(1, 25))
     segment = ('ns', '111|112|113|114|115')
@@ -222,6 +142,7 @@ class Driver(BaseDriver):
         self.handle = None
         self.model = 'NS_MCI'  # 默认为设备名字
         self.srate = 8e9
+        self.ad_srate = 4e9
         self.addr = addr
         self.timeout = timeout
         self.chs = set()  # 记录配置过的ch通道
@@ -229,7 +150,11 @@ class Driver(BaseDriver):
         self.coef_cache = {}
         self.res_maps = {}
         self.probe_da_wave = {}
-        self.capture_cmds: "dict[int, CaptureCmd]" = {}
+        # self.probe_delay = 32e-9
+        self.probe_delay = 0
+        self.capture_cmds: "dict[int, list[CaptureCmd]]" = {}
+        self.capture_cali_param: "dict[int, np.ndarray]" = {}
+        self.capture_points: "dict[int, np.ndarray]" = {}
         self.demodulate_mode = DemodulateMode.MORE_QUBIT
 
     def open(self, **kw):
@@ -242,40 +167,42 @@ class Driver(BaseDriver):
         DArate = 8e9
         ADrate = 4e9
         sysparam = {
-            "MixMode": 1,
+            "MixMode": 2,
             "RefClock": "out",
             "DArate": DArate,
             "ADrate": ADrate,
             "CaptureMode": 0,
             "INMixMode": 2,  # 4～6 GHz 取 1， 6 ～ 8 GHz 取 2
         }
+        sysparam.update(kw.get('system_parameter', {}))
 
         device = MCIDriver(self.addr, self.timeout)
         device.open(system_parameter=sysparam)
         self.handle = device
 
     def granularity4ns(self, delay):
-        # 4ns取整
-        out_delay = round(
-            delay // 4e-9 * 4e-9, 10
-        )
-        return out_delay
+        # points_4ns = 16  # self.ad_srate*4e-6
+        return delay // 4 * 4
 
     @staticmethod
-    def get_sequence_in_time(coef_info: dict) -> list[CaptureCmd]:
+    def _delay2_phase(delay, freq):
+        return 2 * np.pi * freq * (delay * 1e-9)
+
+    def in_sequence_in_time(self, coef_info: dict) -> list[CaptureCmd]:
         w_list = coef_info.get('wList', [])
         time_segments: "list[ProbeSegment]" = []
 
-        for wave in w_list:
-            t0 = wave['t0']
+        for idx, wave in enumerate(w_list):
+            t0 = int(round(wave['t0'] * 1e9))
             weight_expr = wave['weight']
 
             # 假设 weight 表达式格式为 "square(X) >> Y"，我们提取实际时间宽度
             # duration = float(weight_expr.split('>>')[1].strip())
             _start, _stop, _ = wave_eval(weight_expr).bounds
+            _start, _stop = int(round(_start * 1e9)), int(round(_stop * 1e9))
 
             # 将区间加入列表
-            seg = ProbeSegment(t0+_start, t0+_stop, wave['Delta'])
+            seg = ProbeSegment(t0 + _start, t0 + _stop, wave['Delta'], idx)
             time_segments.append(seg)
 
         # 按起始时间排序
@@ -284,61 +211,148 @@ class Driver(BaseDriver):
         # 结果存储
         non_overlapping_segments: list[CaptureCmd] = []
         current_start, current_end = time_segments[0].start, time_segments[0].stop
-        current_cmd = CaptureCmd(0, 0, 0, 0, [time_segments[0].freq])
+        current_cmd = CaptureCmd(0, 0, 0, 0, [time_segments[0].freq], [0.], [time_segments[0].idx])
         pointer = 0
 
         for seg in time_segments[1:]:
             if seg.start > current_end:
                 # 如果不重叠，保存当前段并移动到下一段
-                current_cmd = current_cmd._replace(start=current_start-pointer)
+                if pointer == 0:
+                    current_cmd = current_cmd._replace(start=current_start)
+                else:
+                    current_cmd = current_cmd._replace(start=current_start - self.probe_delay)
                 current_cmd = current_cmd._replace(ad_duration=current_end - current_start)
-                current_cmd = current_cmd._replace(delay=230e-9)
+                current_cmd = current_cmd._replace(delay=self.probe_delay)
                 current_cmd = current_cmd._replace(da_duration=current_end - current_start)
                 non_overlapping_segments.append(current_cmd)
 
-                current_cmd = CaptureCmd(0, 0, 0, 0, [seg.freq])
-                pointer += current_end
+                current_cmd = CaptureCmd(0, 0, 0, 0, [seg.freq], [0.], [seg.idx])
+                pointer = current_end
                 current_start, current_end = seg.start, seg.stop
             else:
                 # 如果有重叠，扩展当前段
                 current_end = max(current_end, seg.stop)
+                current_cmd.idx_list.append(seg.idx)
                 current_cmd.freqs.append(seg.freq)
+                # 由delay换算解缠绕相位
+                current_cmd.delays.append(seg.start - current_start)
         else:
             # 添加最后一个段
-            current_cmd = current_cmd._replace(start=current_start - pointer)
+            current_cmd = current_cmd._replace(start=current_start - self.probe_delay)
             current_cmd = current_cmd._replace(ad_duration=current_end - current_start)
-            current_cmd = current_cmd._replace(delay=230e-9)
+            current_cmd = current_cmd._replace(delay=self.probe_delay)
             current_cmd = current_cmd._replace(da_duration=current_end - current_start)
             non_overlapping_segments.append(current_cmd)
         return non_overlapping_segments
 
-    def generate_para(self, coef_info, ch):
-        res_map = []
+    def generate_in_program(self, coef_info, ch):
         freq_map = []
         seq_param = []
 
-        self.capture_cmds[ch] = seq = self.get_sequence_in_time(coef_info)
+        self.capture_cmds[ch] = seq = self.in_sequence_in_time(coef_info)
 
         for segment in seq:
             freq_map.extend(segment.freqs)
-        freq_map = list(set(freq_map))
+            freq_map = list(set(freq_map))
 
+        _t_end = 0
+        res_map = [[]]*len(coef_info['wList'])
+        phase_map = [0]*len(coef_info['wList'])
+        points_map = [0]*len(coef_info['wList'])
         for cap_num, segment in enumerate(seq):
+            _align_start = self.granularity4ns(segment.start)
+            _start_diff = segment.start - _align_start
+            _align_end = ceil((segment.start+segment.ad_duration)/4)*4
             seq_param.append([
-                segment.start, segment.ad_duration, segment.delay, segment.da_duration
+                (_align_start-_t_end)*1e-9,
+                (_align_end-_align_start)*1e-9,
+                segment.delay*1e-9,
+                (_align_end-_align_start)*1e-9,
             ])
-            for freq in segment.freqs:
-                res_map.append([freq_map.index(freq), cap_num])
+            _t_end = _align_end
+            for idx, delay, freq in zip(segment.idx_list, segment.delays, segment.freqs):
+                res_map[idx] = [freq_map.index(freq), cap_num]
+                phase_map[idx] = self._delay2_phase(delay + _start_diff, freq)
+                points_map[idx] = segment.ad_duration * 1e-9 * self.ad_srate
 
         self.res_maps[ch] = res_map
-        self.handle.set("Program", program_cap(seq_param), ch)
-        self.handle.set("FreqList", freq_map, ch)
-        self.handle.set("TimeWidth", 2e-6, ch)
+        self.capture_cali_param[ch] = np.exp(-1j * np.array(phase_map)).reshape((-1, 1))
+        self.capture_points[ch] = np.array(points_map).reshape((-1, 1))
+        return program_cap(seq_param), freq_map
+
+    def out_sequence_in_time(self, wave_list: list):
+        last_start = wave_list[0][0]
+        last_stop = wave_list[0][1]
+        temp_w = [wave_list[0][2]]
+        _res = []
+
+        for idx, (start, stop, seg) in enumerate(wave_list[1:]):
+            if start > last_stop:
+                _res.append([last_start, last_stop, np.hstack(temp_w)])
+                last_start = start
+                last_stop = stop
+                temp_w.clear()
+                temp_w.append(seg)
+            else:
+                last_stop = max(last_stop, stop)
+                temp_w.append(seg)
+        else:
+            _res.append([last_start, last_stop, np.hstack(temp_w)])
+        return _res
+
+    def gen_wave_frag(self, x, wave: "Waveform"):
+        range_list = np.searchsorted(x, wave.bounds)
+        # ret = np.zeros_like(x)
+        ret = []
+        start, stop = 0, 0
+        for i, stop in enumerate(range_list):
+            if start < stop and wave.seq[i] != _zero:
+                _w = copy.deepcopy(wave)
+                _w.start = start / self.srate
+                _w.stop = stop / self.srate
+                part = _w.sample(self.srate)
+                part = part if part is None else part[:(stop-start)]
+                ret.append((start, stop, part))
+            start = stop
+        else:
+            if not ret:
+                ret.append((0, 128, np.zeros((128,))))
+        return ret
+
+    def generate_out_program(self, _wave, ch):
+        align_points = 32  # 4ns*8e9
+        if isinstance(_wave, WaveVStack):
+            _wave = _wave.simplify()
+        if len(_wave.seq) == 1 and _wave.seq[0] == _zero:
+            wave_list = [(0, 128, np.zeros((128,)))]
+        else:
+            _wave.stop = _wave.bounds[-2]
+            wave_list = self.gen_wave_frag(
+                np.linspace(_wave.start, _wave.stop, int((_wave.stop - _wave.start) * self.srate)), _wave)
+        # print(f'generate_out_program: {_wave.start=}, {_wave.stop=}, {wave_list=}, {ch=}')
+        _t_end = 0
+        para = []
+        wave = self.out_sequence_in_time(wave_list)
+
+        for i in wave:
+            wait = (i[0] - _t_end)
+            align_wait = wait // align_points * align_points
+            zero_num = wait - align_wait
+            align_end = ceil(i[1] / align_points) * align_points
+            align_wave = [np.zeros(zero_num), i[2], np.zeros([align_end - i[1]])]
+            para.append([align_wait / self.srate, np.hstack(align_wave)])
+            _t_end = align_end
+        return program_da(para)
 
     def get_coef_res(self, iq_res, ch):
         res = []
         for (freq_num, cap_num) in self.res_maps[ch]:
             res.append(iq_res[freq_num][cap_num::len(self.capture_cmds[ch])])
+        # 采样点归一化
+        res = np.array(res) / self.capture_points[ch]
+        # 校准相位
+        res *= self.capture_cali_param[ch]
+
         return res
 
     def close(self, **kw):
@@ -358,24 +372,25 @@ class Driver(BaseDriver):
 
     def write(self, name: str, value, **kw):
         channel = kw.get('ch', 1)
-        print(name, value, "write" * 4)
+        # print(f'NS_DDS_v3 write: {name=}, {channel=}')
         if name in {'Coefficient'}:
-            # data, f_list, numberOfPoints, phases, points, _ = get_coef(value, 4e9)
-
-            # print('DemoPoints'*10, points, channel)
-            # self.handle.set('DemoPoints', points, channel)      ###############   16ns-oscillation problem
-            # self.handle.set('DemodulationParam', data, channel)
             coef_info = value
             self.chs.add(channel)
-            self.generate_para(coef_info, channel)
+            kernel, freq_map = self.generate_in_program(coef_info, channel)
+            self.handle.set("ProgramIN", kernel, channel)
+            self.handle.set('TimeWidth', 2e-6, channel)
+            self.handle.set("FreqList", freq_map, channel)
             self.coef_cache.update({channel: coef_info})
-        # elif name in {'Waveform'} and isinstance(value, waveforms.Waveform):
-        #     self.probe_da_wave[channel] = value
         elif name in {
             'CaptureMode', 'SystemSync', 'ResetTrig', 'TrigPeriod',
             'TrigFrom'
         }:
             pass
+        elif name in {
+            'GenWave', 'Waveform'
+        } and isinstance(value, Waveform):
+            kernel_da = self.generate_out_program(value, channel)
+            self.handle.set("ProgramOUT", kernel_da, channel)
         else:
             if name in {"Shot"}:
                 self.shots = value
@@ -383,18 +398,13 @@ class Driver(BaseDriver):
 
     def read(self, name: str, **kw):
         channel = kw.get('ch', 1)
-        print(name, kw, "READ " * 6)
         if name in {"IQ"}:
-            # if channel not in self.chs:
-            #     result = self.IQ_cache[channel]
-            #     print("result.shape, cache", result)
-            # else:
-            iq_res = self.handle.get("IQ", channel, round(self.shots * len(self.capture_cmds[channel])))  # / self.points
-
-            # print(np.array(iq_res).shape, "iq shape")
-            result = np.array(self.get_coef_res(iq_res, channel)).T
-            # print(result.shape, "result.shape," * 3)
-            if len(self.chs) != 0:
+            iq_res = self.handle.get(
+                "IQ", channel, round(self.shots * len(self.capture_cmds[channel]))
+            )
+
+            result = self.get_coef_res(iq_res, channel).T
+            if len(self.chs) != 0 and channel in self.chs:
                 self.chs.remove(channel)
             # self.IQ_cache.update({channel: result})
             if len(self.chs) == 0:
@@ -402,3 +412,95 @@ class Driver(BaseDriver):
         else:
             result = self.handle.get(name, channel)
         return result
+
+
+if __name__ == '__main__':
+    co = {'start': 0.0, 'stop': 10e-06, 'wList': [
+        {'Delta': 6796613333.333333, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 1.5e-08, 'phi': 2.4311851282940524, 'threshold': 9.645718574523926},
+        {'Delta': 6965129999.666667, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 2.345e-06, 'phi': 2.1739656328752264, 'threshold': 20.36802101135254},
+        {'Delta': 6866353333.333333, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 2.345e-06, 'phi': 1.851749364542847, 'threshold': 21.65827751159668},
+        {'Delta': 6796613333.333333, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 5.175e-06, 'phi': 2.4311851282940524, 'threshold': 9.645718574523926},
+        {'Delta': 6965129999.666667, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 5.175e-06, 'phi': 2.1739656328752264, 'threshold': 20.36802101135254},
+        {'Delta': 6866353333.333333, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 5.175e-06, 'phi': 1.851749364542847, 'threshold': 21.65827751159668},
+        {'Delta': 6796613333.333333, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 7.805e-06, 'phi': 2.4311851282940524, 'threshold': 9.645718574523926},
+        {'Delta': 6796613333.333333, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 8.805e-06, 'phi': 2.4311851282940524, 'threshold': 9.645718574523926},
+        {'Delta': 6965129999.666667, 'phase': -0.0, 'weight': 'square(8e-07) >> 4e-07', 'window': (0, 1024), 'w': None,
+         't0': 9.005e-06, 'phi': 2.4311851282940524, 'threshold': 9.645718574523926}
+    ]}
+    import matplotlib.pyplot as plt
+    from nsqdriver import QSYNCDriver
+    import time
+    import waveforms as wf
+    from nsqdriver.NS_MCI import SHARED_DEVICE_MEM
+
+    SHARED_DEVICE_MEM.clear_ip()
+    _d = Driver('192.168.0.43', 300)
+    qsync = QSYNCDriver("192.168.0.43")
+    _d = Driver('192.168.0.228', 30)
+    _q = QSYNCDriver('192.168.0.228')
+    time.sleep(5)
+    _wave = wf.zero()
+    for _w in co['wList']:
+        t0 = _w['t0']
+        _wave += (wf.wave_eval(_w['weight']) * wf.cos(2 * np.pi * _w['Delta'])) >> t0
+    # _wave = _wave << 50e-9
+    _wave.start = 0
+    _wave.stop = 60e-6
+
+    _wave(np.linspace(0, 20e-6, int(20e-6 * 8e9)), frag=True)
+
+    wave = _wave.sample(8e9) / 3
+    _wave
+
+    for ch in range(3, 4):
+        _d.write('GenWave', _wave, ch=ch)
+        _d.write('Coefficient', co, ch=ch)
+    # res = _d.generate_para(co, 1)
+    _d.write("Coefficient", co, ch=2)
+    ch = 2
+    # wave = wf.cos(2*wf.pi*0.15e9)
+    # wave.start = 0
+    # wave.stop = 1e-6
+
+    _wave = waveforms.zero()
+    for _w in co['wList']:
+        t0 = _w['t0']
+        _wave += (waveforms.wave_eval(_w['weight']) * waveforms.cos(2 * np.pi * _w['Delta'])) >> t0
+    # _wave = _wave << 50e-9
+    _wave.start = 0
+    _wave.stop = co["stop"]
+    plt.plot(_wave.sample(8e9))
+    plt.show()
+    _d.write("GenWave", _wave, ch=2)
+    _d.set('CaptureMode', 1)
+    shots = 1024
+    qsync.set('Shot', shots)
+    _d.write('Shot', shots)
+    _d.set('StartCapture')
+    qsync.set('GenerateTrig', 400e-6)
+    time.sleep(400e-6 * shots + 0.5)
+    data = _d.get('TraceIQ', ch)
+    data = np.array(data)
+    print(data.shape)
+    data = data.reshape((shots, -1))
+    # qsync.set("Shot", 0xFFFFFFFF)
+    # qsync.set("GenerateTrig", 500e-6)
+    plt.figure()
+    plt.plot(data.mean(axis=0)[:])
+    plt.show()
+    _d.set('CaptureMode', 0)
+    _d.write("Coefficient", co, ch=2)
+    _d.write("GenWave", _wave, ch=2)
+    _d.set('StartCapture')
+    qsync.set('GenerateTrig', 40e-6)
+    data = _d.read("IQ", ch=2)
+    print(20 * np.log10(np.abs(data.mean(axis=0))))
+    pass

nsqdriver/NS_MCI.py

@@ -9,8 +9,10 @@ import xmlrpc.client
 from xmlrpc.client import Transport
 from multiprocessing import shared_memory
 from functools import wraps
+from enum import Enum
 
 import numpy as np
+
 try:
     import waveforms
     HAS_WAVEFORMS = True
@@ -78,6 +80,12 @@ def solve_rpc_exception(func):
     return wrapper
 
 
+class DataMode(str, Enum):
+    DIRECT = 'direct'
+    NORMAL = 'normal'
+    RDMA = 'rdma'
+
+
 class Driver(BaseDriver):
     CHs = list(range(1, 25))
     segment = ('ns', '111|112|113|114|115')
@@ -153,6 +161,7 @@ class Driver(BaseDriver):
         self.handle = None
         self.model = 'NS_MCI'  # 默认为设备名字
         self.srate = 6e9
+        self.data_mode = DataMode.NORMAL
         self.device_online = True
         self.has_start_capture = False
         self.backend_version = (0, 0, 0)
@@ -285,20 +294,25 @@ class Driver(BaseDriver):
             return
         print_debug(f'Driver: get操作被调用{name}')
         self.has_start_capture = False
+        if name in {'Trace', 'TraceIQ'} and self.backend_version >= (2, 8, 0):
+            data_mode = self.get('DataMode', channel)
+            data_mode = DataMode(data_mode) if data_mode else DataMode.NORMAL
+            if data_mode == DataMode.DIRECT:
+                return self._get_trace_data(channel)
 
         func = self.fast_rpc.rpc_get
         tmp = func(name, channel, value)
         tmp = RPCValueParser.load(tmp)
         return tmp
 
-    def update_firmware(self, file_path, target='all'):
+    def update_firmware(self, file_path, target='all', _id=0):
         if not self.device_online:
             return
         import os
         if not os.path.exists(file_path):
             raise ValueError(f'文件路径: {file_path} 不存在')
         with open(file_path, 'rb') as fp:
-            result = self.handle.update_rfs_firmware(fp.read(), target)
+            result = self.handle.update_rfs_firmware(fp.read(), target, _id)
         if result:
             print(f'设备{self.addr} 固件更新成功，3s后设备自动重启')
         else:
@@ -331,6 +345,15 @@ class Driver(BaseDriver):
             print(f'设备{self.addr}-指令{button_name}执行失败')
         return flag
 
+    def _get_trace_data(self, channel):
+        res = self.get('ShmPath', channel)
+        if not res:
+            return
+        _path, chnl, chnl_num, shots, points = res
+        shm = shared_memory.SharedMemory(name=_path, create=False)
+        data = np.frombuffer(shm.buf, dtype=np.int16).reshape((chnl_num, shots, points))
+        return data[chnl], data
+
     def _connect(self, addr=None, port=5001, timeout=None):
         """
         获取到指定ip的tcp连接

nsqdriver/__init__.py

@@ -4,7 +4,7 @@ from .NS_CST import Driver as CSTDriver
 from .compiler.ns_wave import InsChannel
 from .compiler.py_wave_asm import nsw_config, AssemblyError
 
-version_pack = (0, 12, 10)
+version_pack = (0, 12, 12)
 
 __version__ = '.'.join(str(_) for _ in version_pack)
 __all__ = ['MCIDriver', 'QSYNCDriver', 'CSTDriver', 'InsChannel']

{nsqdriver-0.12.10.dist-info → nsqdriver-0.12.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nsqdriver
-Version: 0.12.10
+Version: 0.12.12
 Summary: Q series measurement and control equipment driver interface
 Home-page: https://g2hoyqcmh4.feishu.cn/wiki/Jgt1wxlKniveYQkqCgbcJHsMnoe
 Classifier: Intended Audience :: Developers

nsqdriver-0.12.12.dist-info/RECORD

@@ -0,0 +1,40 @@
+nsqdriver/NS_CST.py,sha256=zA5YcM65v66EqwBnplDvA6HM0I-y8damDOerE2CKyZE,8137
+nsqdriver/NS_DDS_v3.py,sha256=sawKNLeSEmLKkKfPe-O9-LZCAY1lyTPEN3YJiAYU2Lc,20784
+nsqdriver/NS_MCI.py,sha256=PO5VMtxQXNCOfLYuHsIZ6MNhZCkJhyNTgx0E6lPcMYE,22520
+nsqdriver/NS_QSYNC.py,sha256=bPD0cAUehRXpTDwMNZutB5AWhZM7iwKBD5t5jmJiBF4,27900
+nsqdriver/__init__.py,sha256=pL9i93d2rNy7GuHRrA4nVAfVsBFyrK4dsrJXAl4fwm0,383
+nsqdriver/common.py,sha256=5BRActb9TgNdVwWtfuZ_gki47H1WbABzYr5XbxLKlh4,519
+nsqdriver/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsqdriver/compiler/assembler.cp38-win_amd64.pyd,sha256=kWqjyifGKtUaxWlwim3YZPBL7tLc_Uin_c5zRgpkPqc,409088
+nsqdriver/compiler/ns_wave.cp38-win_amd64.pyd,sha256=BAtvcfoPA7dAXeDm1vSWAi4YZ_0UYrT0PfvIrPVSBKc,239616
+nsqdriver/compiler/ns_wave.pyi,sha256=axQaxrMaKRPx8k9sDVlRj3SjR03AmXUDzkVW4D_2RJw,3975
+nsqdriver/compiler/py_wave_asm.cp38-win_amd64.pyd,sha256=q8SeFrutKbTfxxk3G0vvT3j_5chw1QlDPWejASnV2Ek,334848
+nsqdriver/compiler/py_wave_asm.pyi,sha256=PqEZuNt83CCu_FJUczUjStowOz2TBgvfIytGanFPHuQ,685
+nsqdriver/nswave/__init__.py,sha256=rAU1XD58JBF7iAYB5LVD-ZlEmQq9wyJrsRVHF-OOrzI,302
+nsqdriver/nswave/_asm.pyi,sha256=f8IjCLPIocBZXTC8F5GFTlI6ZDa5-hhShJPjL166K4o,2846
+nsqdriver/nswave/_checkers.cp38-win_amd64.pyd,sha256=FAXsIf-WzS9PI_ADDYwHaXv04xYVrNS-hLXk8BEoBIc,222720
+nsqdriver/nswave/_checkers.pyi,sha256=931KCK3B87dE0qjtWcEt6C-_KSIdH0RRiIYer8p6Tgg,1459
+nsqdriver/nswave/_errors.cp38-win_amd64.pyd,sha256=c_HKsXXB4CcnbLtKdvY5nZFaycWteH_1Xaux8CN5GC0,79360
+nsqdriver/nswave/_errors.pyi,sha256=A4LLc1zu6blJgmaAW_Wdx19jvFe1fkIggkTgYaQ8BIM,664
+nsqdriver/nswave/_functions.cp38-win_amd64.pyd,sha256=cQUWtZqwSyJvmAqFVvaCxmFG3bvkyrO7LuWvY3iqGi0,218112
+nsqdriver/nswave/_functions.pyi,sha256=wOzfZITAzupxAONxGELNF_U-XMy1CTdr8iU8UeszTQk,1992
+nsqdriver/nswave/_ir.cp38-win_amd64.pyd,sha256=vAzSv5v8yO-LNQHUIynrv1-IrGZUQ6lZ9MmttUVCEuk,463360
+nsqdriver/nswave/_ir.pyi,sha256=nPh7se2s1D80zMLF_bSrA4WpKI7uk-hrLRPs5JHadxc,7413
+nsqdriver/nswave/_ir_pass.cp38-win_amd64.pyd,sha256=1YV60qpO4HMr8PPPDBy8E2yie5qsA5Rd9onYyeWs5ro,57856
+nsqdriver/nswave/_ir_pass.pyi,sha256=UmQVLgcfX1rw9HuMorRCensJtxB4b7zh7uyIIlTF_A0,289
+nsqdriver/nswave/_optimizations.cp38-win_amd64.pyd,sha256=Yoh8kIgDOQW5vZcmx6GUzMhENRgRXFH8KHDfheWc7ng,68096
+nsqdriver/nswave/_optimizations.pyi,sha256=6WxLlO1aJEMMGB4qL3iSr0l43b6pSH-7qRSHXzCQQa8,508
+nsqdriver/nswave/_rules.cp38-win_amd64.pyd,sha256=GuBPm1VxrGoSBiCSIaIcSQ0BB84UMRE7y0O9xPg_Wk0,202752
+nsqdriver/nswave/_rules.pyi,sha256=bMynUPRkrIfTNXPt0K7Rqy5cp4B-4EIdolznVBJaaAM,1926
+nsqdriver/nswave/_simulator.cp38-win_amd64.pyd,sha256=Avse6Yrh4xnZ4kRFB0naKO8ODR7GT7fEqRdohqtYVl4,146944
+nsqdriver/nswave/_translate.cp38-win_amd64.pyd,sha256=uQkbjb2VVsWa8jQx3l1U5LGbwGtQKJ9QYk-VbR8ZjXU,126976
+nsqdriver/nswave/_translate.pyi,sha256=f0N24eSL7hKj2R04W-EFeEo9A8UYfzHOta7LQrDn-UA,387
+nsqdriver/nswave/kernel.cp38-win_amd64.pyd,sha256=MPsHCtQCX8XQf0KriPUFfz_FTe0-QBCSnEbNSvW6Vq4,326144
+nsqdriver/nswave/kernel.pyi,sha256=GBjjcfGBFiZ7_PCSgOWJcfVqckYg_r3j7PsMpUeaozE,2009
+nsqdriver/wrapper/AWG_ADC.py,sha256=wLtkbJe39hDcnbWZ-8jyGZ78RQtn7iAZ7P7H0n-2IWU,19733
+nsqdriver/wrapper/ND_NSMCI.py,sha256=e0j7BUdfrhfYb1GqBPlO4vSoZPXTKyictXy1nPvoMFE,6533
+nsqdriver/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsqdriver-0.12.12.dist-info/METADATA,sha256=Nh-T0M5KLBYAR8XU3UjXMxX6PiXUXpCsJwn7c_LZCGs,4385
+nsqdriver-0.12.12.dist-info/WHEEL,sha256=rTcqimtzpX3smAWAhGmiRSWAxTY4PqYPNE-p4kscHDQ,99
+nsqdriver-0.12.12.dist-info/top_level.txt,sha256=o7EbQoFO6BoaG3KGbS9Lg_aRheZSY5KYzoYuI9vx-AI,10
+nsqdriver-0.12.12.dist-info/RECORD,,

nsqdriver-0.12.10.dist-info/RECORD

@@ -1,39 +0,0 @@
-nsqdriver/NS_CST.py,sha256=zA5YcM65v66EqwBnplDvA6HM0I-y8damDOerE2CKyZE,8137
-nsqdriver/NS_DDS_v3.py,sha256=rX7EPJzoSuRObi0WyP9etgCBMEL1PCgOxcLy0AcK3Yg,15841
-nsqdriver/NS_MCI.py,sha256=1zCpqkHr4tQdgb5iaMTKcjrhPKuWNSFUKR7V_8patG8,21659
-nsqdriver/NS_QSYNC.py,sha256=bPD0cAUehRXpTDwMNZutB5AWhZM7iwKBD5t5jmJiBF4,27900
-nsqdriver/__init__.py,sha256=n1jDrXgSPFkxyLVUjc2s1RFLdC6hT9YJ3tasYbamjMg,383
-nsqdriver/common.py,sha256=5BRActb9TgNdVwWtfuZ_gki47H1WbABzYr5XbxLKlh4,519
-nsqdriver/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsqdriver/compiler/assembler.cp38-win_amd64.pyd,sha256=EX4u6q3cjna98_ZZK4q9OGAOLIzg9kabtE68gAnPtvw,383488
-nsqdriver/compiler/ns_wave.cp38-win_amd64.pyd,sha256=7OvVqdsPyB74-JR7bqPmHjt4ba2yKqGbv4FsZfy8tlI,240128
-nsqdriver/compiler/ns_wave.pyi,sha256=axQaxrMaKRPx8k9sDVlRj3SjR03AmXUDzkVW4D_2RJw,3975
-nsqdriver/compiler/py_wave_asm.cp38-win_amd64.pyd,sha256=TTA35cUhCHzNvldvguwq7fP_TlKfGx5IQpVj_4xDTQ4,335360
-nsqdriver/compiler/py_wave_asm.pyi,sha256=PqEZuNt83CCu_FJUczUjStowOz2TBgvfIytGanFPHuQ,685
-nsqdriver/nswave/__init__.py,sha256=rAU1XD58JBF7iAYB5LVD-ZlEmQq9wyJrsRVHF-OOrzI,302
-nsqdriver/nswave/_asm.pyi,sha256=f8IjCLPIocBZXTC8F5GFTlI6ZDa5-hhShJPjL166K4o,2846
-nsqdriver/nswave/_checkers.cp38-win_amd64.pyd,sha256=npxxkw2PDmv2jEeGdsnzlmjuY_18MbzLL-513-XFDEE,177152
-nsqdriver/nswave/_checkers.pyi,sha256=931KCK3B87dE0qjtWcEt6C-_KSIdH0RRiIYer8p6Tgg,1459
-nsqdriver/nswave/_errors.cp38-win_amd64.pyd,sha256=YyZeXiZzqu1Zwk3X0mdjwgiySUJwc7OiQveL7q4DiSM,79872
-nsqdriver/nswave/_errors.pyi,sha256=A4LLc1zu6blJgmaAW_Wdx19jvFe1fkIggkTgYaQ8BIM,664
-nsqdriver/nswave/_functions.cp38-win_amd64.pyd,sha256=u-sgEJsOCh0hfHL3PkwlsXHWHZZPihuXcRE-xPef0EA,104448
-nsqdriver/nswave/_functions.pyi,sha256=wOzfZITAzupxAONxGELNF_U-XMy1CTdr8iU8UeszTQk,1992
-nsqdriver/nswave/_ir.cp38-win_amd64.pyd,sha256=0ts5Mc6KYj--olgsLAXzQTNKCvavbReeVdEY_lDtuhw,320512
-nsqdriver/nswave/_ir.pyi,sha256=nPh7se2s1D80zMLF_bSrA4WpKI7uk-hrLRPs5JHadxc,7413
-nsqdriver/nswave/_ir_pass.cp38-win_amd64.pyd,sha256=V8d0DZ-WOUeJHYToFEdOwBGIsoI4OguJjEAKP77uMgY,48128
-nsqdriver/nswave/_ir_pass.pyi,sha256=UmQVLgcfX1rw9HuMorRCensJtxB4b7zh7uyIIlTF_A0,289
-nsqdriver/nswave/_optimizations.cp38-win_amd64.pyd,sha256=R94wDZlz5_xgoI6Ti3hE1iW4DGFt7seUA4Wh2Akcan8,56832
-nsqdriver/nswave/_optimizations.pyi,sha256=6WxLlO1aJEMMGB4qL3iSr0l43b6pSH-7qRSHXzCQQa8,508
-nsqdriver/nswave/_rules.cp38-win_amd64.pyd,sha256=HkrFJsUb3pR5Q7I2q030AokBAAIPnFp0wVTkiT-9tfI,187904
-nsqdriver/nswave/_rules.pyi,sha256=bMynUPRkrIfTNXPt0K7Rqy5cp4B-4EIdolznVBJaaAM,1926
-nsqdriver/nswave/_translate.cp38-win_amd64.pyd,sha256=hpZH8-q5cnyYmyZxxZXLlwPln5OwoXjJ1TCmkV_9je8,110080
-nsqdriver/nswave/_translate.pyi,sha256=f0N24eSL7hKj2R04W-EFeEo9A8UYfzHOta7LQrDn-UA,387
-nsqdriver/nswave/kernel.cp38-win_amd64.pyd,sha256=_pOzIrgrocJrGDfZwY85CUxPyDUZ7QYhLK1z42gIvP0,263168
-nsqdriver/nswave/kernel.pyi,sha256=GBjjcfGBFiZ7_PCSgOWJcfVqckYg_r3j7PsMpUeaozE,2009
-nsqdriver/wrapper/AWG_ADC.py,sha256=wLtkbJe39hDcnbWZ-8jyGZ78RQtn7iAZ7P7H0n-2IWU,19733
-nsqdriver/wrapper/ND_NSMCI.py,sha256=e0j7BUdfrhfYb1GqBPlO4vSoZPXTKyictXy1nPvoMFE,6533
-nsqdriver/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsqdriver-0.12.10.dist-info/METADATA,sha256=CbStcfueA-cknxGr_cjPmRm_xtSPFcXjcP1K1R8d-EU,4385
-nsqdriver-0.12.10.dist-info/WHEEL,sha256=rTcqimtzpX3smAWAhGmiRSWAxTY4PqYPNE-p4kscHDQ,99
-nsqdriver-0.12.10.dist-info/top_level.txt,sha256=o7EbQoFO6BoaG3KGbS9Lg_aRheZSY5KYzoYuI9vx-AI,10
-nsqdriver-0.12.10.dist-info/RECORD,,