qlsdk2 0.6.0a9__tar.gz → 0.6.0a12__tar.gz

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qlsdk2
-Version: 0.6.0a9
+Version: 0.6.0a12
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding='utf-8' ) as fh:
 
 setuptools.setup(
     name="qlsdk2",
-    version="0.6.0a9",
+    version="0.6.0a12",
     author="hehuajun",
     author_email="hehuajun@eegion.com",
     description="SDK for quanlan device",

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/core/entity/__init__.py

@@ -19,7 +19,8 @@ class RscPacket(Packet):
         self.filter = None
         self.data_len = None
         self.trigger = None
-        self.eeg = None
+        self.eeg = None # 数字信号
+        self.eeg_p = None # 物理值
     
     @staticmethod
     def transfer(body: bytes) -> 'RscPacket':
@@ -55,19 +56,13 @@ class RscPacket(Packet):
         return packet
         
     def __str__(self):
-        return f"""
-            time_stamp: {self.time_stamp}
-            pkg_id: {self.pkg_id}
-            origin_sample_rate: {self.origin_sample_rate}
-            sample_rate: {self.sample_rate}
-            sample_num: {self.sample_num}
-            resolution: {self.resolution}
-            filter: {self.filter}
-            channels: {self.channels}
-            data len: {self.data_len}
-            trigger: {self.trigger}
-            eeg: {self.eeg}
-        """
+        return f"""[
+            "time_stamp": {self.time_stamp}
+            "pkg_id": {self.pkg_id}
+            "channels": {self.channels}
+            "trigger": {self.trigger}
+            "eeg": {self.eeg}
+        ]"""
         
 class ImpedancePacket(Packet):
     def __init__(self):
@@ -96,12 +91,12 @@ class ImpedancePacket(Packet):
         return packet
 
     def __str__(self):
-        return f"""
-            time_stamp: {self.time_stamp}
-            pkg_id: {self.pkg_id}
-            channels: {self.channels}
-            impedance: {self.impedance}
-        """
+        return f"""[
+            "time_stamp": {self.time_stamp}
+            "pkg_id": {self.pkg_id}
+            "channels": {self.channels}
+            "impedance": {self.impedance}
+        ]"""
         
     
 class C256RSPacket(Packet):

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/persist/ars_edf.py

@@ -85,67 +85,67 @@ class ARSKindlingEDFHandler(object):
             "D" : [7, 8, 5, 6, 3, 4, 1, 2, 9, 10, 11, 12, 13, 14],
         }
         
-        self._channel_mapping = {
-            1: "D7", 
-            2: "D8",
-            3: "D5", 
-            4: "D6",
-            5: "D3", 
-            6: "D4",
-            7: "D1", 
-            8: "D2",
-            9: "D9", 
-            10: "D10",
-            11: "D11", 
-            12: "D12",
-            13: "D13", 
-            14: "D14",
+        # self._channel_mapping = {
+        #     1: "D7", 
+        #     2: "D8",
+        #     3: "D5", 
+        #     4: "D6",
+        #     5: "D3", 
+        #     6: "D4",
+        #     7: "D1", 
+        #     8: "D2",
+        #     9: "D9", 
+        #     10: "D10",
+        #     11: "D11", 
+        #     12: "D12",
+        #     13: "D13", 
+        #     14: "D14",
             
-            17: "C7", 
-            18: "C8",
-            19: "C5", 
-            20: "C6",
-            21: "C3", 
-            22: "C4",
-            23: "C1", 
-            24: "C2",
-            25: "C9", 
-            26: "C10",
-            27: "C11", 
-            28: "C12",
-            29: "C13", 
-            30: "C14",
+        #     17: "C7", 
+        #     18: "C8",
+        #     19: "C5", 
+        #     20: "C6",
+        #     21: "C3", 
+        #     22: "C4",
+        #     23: "C1", 
+        #     24: "C2",
+        #     25: "C9", 
+        #     26: "C10",
+        #     27: "C11", 
+        #     28: "C12",
+        #     29: "C13", 
+        #     30: "C14",
             
-            33: "B7", 
-            34: "B8",
-            35: "B5", 
-            36: "B6",
-            37: "B3", 
-            38: "B4",
-            39: "B1", 
-            40: "B2",
-            41: "B9", 
-            42: "B10",
-            43: "B11", 
-            44: "B12",
-            45: "B13", 
-            46: "B14",
+        #     33: "B7", 
+        #     34: "B8",
+        #     35: "B5", 
+        #     36: "B6",
+        #     37: "B3", 
+        #     38: "B4",
+        #     39: "B1", 
+        #     40: "B2",
+        #     41: "B9", 
+        #     42: "B10",
+        #     43: "B11", 
+        #     44: "B12",
+        #     45: "B13", 
+        #     46: "B14",
             
-            49: "A7", 
-            50: "A8",
-            51: "A5", 
-            52: "A6",
-            53: "A3", 
-            54: "A4",
-            55: "A1", 
-            56: "A2",
-            57: "A9", 
-            58: "A10",
-            59: "A11", 
-            60: "A12",
-            61: "A13", 
-            62: "A14"
-        }
+        #     49: "A7", 
+        #     50: "A8",
+        #     51: "A5", 
+        #     52: "A6",
+        #     53: "A3", 
+        #     54: "A4",
+        #     55: "A1", 
+        #     56: "A2",
+        #     57: "A9", 
+        #     58: "A10",
+        #     59: "A11", 
+        #     60: "A12",
+        #     61: "A13", 
+        #     62: "A14"
+        # }
         
         self._lock = Lock()
         
@@ -172,6 +172,8 @@ class ARSKindlingEDFHandler(object):
             self._device_type = "C64RS"
         elif device_type == 0x40:
             self._device_type = "LJ64S1"
+        elif device_type == 0x60:
+            self._device_type = "ArsKindling"
         else:
             self._device_type = hex(device_type)
         
@@ -200,20 +202,22 @@ class ARSKindlingEDFHandler(object):
          
         #按分区写入数据        
         for k in self._channel_spilt.keys():      
-            logger.trace(f'分区{k}, {self._channel_spilt[k]}')      
-            p = packet
-            self.writeA(p, self._channel_spilt[k], k)
+            logger.trace(f'分区{k}写入数据到文件')  
+            if k in packet.channels.keys():    
+                p = packet
+                self.writeA(p, k)
      
-    def writeA(self, packet: RscPacket, channel_filter, name='A'):
+    def writeA(self, packet: RscPacket, name='A'):
         # 参数检查
-        if packet is None or channel_filter is None:
+        if packet is None:
             logger.warning("空数据，忽略")
             return
+            
+        channels = packet.channels.get(name, None)
+        eeg = packet.eeg.get(name, None)
         
-        channel_pos = intersection_positions(packet.channels, channel_filter)
-        
-        if channel_pos is None or len(channel_pos) == 0 :
-            logger.trace(f"没有指定分区{name}的通道，跳过")
+        if eeg is None :
+            logger.trace(f"分区{name}没有可用的数据，跳过文件写入")
             return
         
         # 分区数据包写入
@@ -226,16 +230,12 @@ class ARSKindlingEDFHandler(object):
             logger.info(f"开始写入分区{name}的数据到文件")
             self._edf_handler[name] = edf_handler
         
-        # 保留本分区的通道和数据
-        channels = [packet.channels[p] for p in channel_pos]
-        eeg = [packet.eeg[p] for p in channel_pos]
-        
         # 新建数据包实例
         data = RscPacket()
         data.time_stamp = packet.time_stamp
         data.pkg_id = packet.pkg_id
         # data.channels = channels
-        data.channels = self.channel_display(channels)
+        data.channels = self.channel_display(channels, name)
         data.origin_sample_rate = packet.origin_sample_rate
         data.sample_rate = packet.sample_rate
         data.sample_num = packet.sample_num
@@ -253,5 +253,5 @@ class ARSKindlingEDFHandler(object):
         for k in self._edf_handler.keys():
             self._edf_handler[k].trigger(desc, cur_time) 
             
-    def channel_display(self, channel):
-        return [self._channel_mapping.get(channel_id, []) for channel_id in channel]
+    def channel_display(self, channel, name: str):
+        return [f'{name}-{channel_id}' for channel_id in channel]

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/rsc/command/__init__.py

@@ -48,8 +48,9 @@ class DeviceCommand(abc.ABC):
         """构建消息体"""
         return b''
     def pack_header(self, body_len: int) -> bytes:
-        device_id = int(self.device.device_id) if self.device and self.device.device_id else 0
+        # device_id = int(self.device.device_id) if self.device and self.device.device_id else 0
         device_type = int(self.device.device_type) if self.device and self.device.device_type else 0
+        device_id = bytes.fromhex(self.device.device_id)[::-1] if self.device.device_id else bytes.fromhex('00000000')
         
         #兼容设计
         b_device_type = None
@@ -61,7 +62,7 @@ class DeviceCommand(abc.ABC):
                 DeviceCommand.HEADER_PREFIX
                 + int(2).to_bytes(1, 'little')     # pkgType  
                 + device_type.to_bytes(1, 'little')
-                + device_id.to_bytes(4, 'little')
+                + device_id
                 + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
                 + self.cmd_code.to_bytes(2, 'little')
             )
@@ -204,6 +205,15 @@ class StopAcquisitionCommand(DeviceCommand):
 class SetImpedanceParamCommand(DeviceCommand):
     cmd_code = 0x411
     cmd_desc = "设置阻抗测量参数"
+    def pack_body(self): 
+
+        return self.device.gen_set_impedance_param()
+    def parse_body(self, body):
+        result = body[8]
+        if result == 0x00:
+            logger.info("阻抗测量参数设置成功")
+        else:
+            logger.warning(f"阻抗测量参数设置失败: {int(result)}")
         
 # 启动阻抗测量
 class StartImpedanceCommand(DeviceCommand):
@@ -211,13 +221,16 @@ class StartImpedanceCommand(DeviceCommand):
     cmd_desc = "启动阻抗测量"
     def pack_body(self):
         body = bytes.fromhex('0000')
-        body += to_bytes(self.device.acq_channels)
+        body += to_bytes(self.device.get_impedance_channels())
         body += bytes.fromhex('0000000000000000') # 8字节占位符
         return body
     
     def parse_body(self, body):
-        logger.info(f"Received StartImpedance response: {body.hex()}")
-        return super().parse_body(body) 
+        result = body[8]
+        if result == 0x00:
+            logger.info("阻抗测量启动成功")
+        else:
+            logger.warning(f"阻抗测量启动失败: {int(result)}")
         
 
 # 停止阻抗测量

qlsdk2-0.6.0a12/src/qlsdk/rsc/device/arskindling.py

@@ -0,0 +1,323 @@
+from multiprocessing import Queue
+from typing import Literal
+from loguru import logger
+from qlsdk.persist import ARSKindlingEDFHandler
+from qlsdk.rsc.interface import IDevice
+from qlsdk.rsc.command import *
+from qlsdk.rsc.device.base import QLBaseDevice
+
+    
+def intersection_positions(A, B):
+    setB = set(B)
+    seen = set()
+    return [idx for idx, elem in enumerate(A) 
+            if elem in setB and elem not in seen and not seen.add(elem)]
+ 
+def get_sorted_indices_basic(A, B):
+    """
+    找出数组A中存在于数组B的元素，并返回这些元素在A中的位置，且顺序与它们在B中的顺序一致。
+
+    参数:
+        A (list): 待查找的数组。
+        B (list): 作为参考的数组。
+
+    返回:
+        list: 一个列表，包含符合条件的元素在A中的索引，顺序与这些元素在B中的出现顺序一致。
+    """
+    # 1. 创建B中元素到其索引的映射
+    b_index_map = {value: idx for idx, value in enumerate(B)}
+    
+    # 2. 筛选A中存在于B的元素，并记录其在A中的索引及在B中的位置
+    # 使用列表推导式，同时避免重复元素干扰（如果B有重复，以第一次出现为准）
+    found_elements = []
+    for idx_a, value in enumerate(A):
+        if value in b_index_map:
+            # 记录: (该元素在A中的索引, 该元素在B中的索引)
+            found_elements.append((idx_a, b_index_map[value]))
+    
+    # 3. 根据元素在B中的位置进行排序
+    # 排序的依据是元组的第二个元素，即 b_index_map[value]
+    found_elements_sorted = sorted(found_elements, key=lambda x: x[1])
+    
+    # 4. 提取排序后在A中的索引，形成结果数组C
+    array_C = [item[0] for item in found_elements_sorted]
+    
+    return array_C
+   
+class ARSKindling(QLBaseDevice):
+    
+    device_type = 0x60 # C64RS设备类型标识符
+    
+    def __init__(self, socket):
+        super().__init__(socket)
+        
+        self.channel_mapping = {
+            "A1": 55, "A2": 56, "A3": 53, "A4": 54, "A5": 51, "A6": 52, "A7": 49, "A8": 50,
+            "A9": 57, "A10": 58, "A11": 59, "A12": 60, "A13": 61, "A14": 62, 
+            
+            "B1": 39, "B2": 40,  "B3": 37, "B4": 38, "B5": 35, "B6": 36, "B7": 33, "B8": 34,
+            "B9": 41, "B10": 42, "B11": 43, "B12": 44, "B13": 45, "B14": 46, 
+            
+            "C1": 23, "C2": 24, "C3": 21, "C4": 22, "C5": 19, "C6": 20, "C7": 17, "C8": 18,
+            "C9": 25, "C10": 26, "C11": 27, "C12": 28, "C13": 29, "C14": 30, 
+            
+            "D1": 7, "D2": 8, "D3": 5, "D4": 6, "D5": 3, "D6": 4, "D7": 1, "D8": 2,
+            "D9": 9, "D10": 10, "D11": 11, "D12": 12, "D13": 13, "D14": 14, 
+        }
+        
+        self._channel_spilt = {
+            "A" : [55, 56, 53, 54, 51, 52, 49, 50, 57, 58, 59, 60, 61, 62],
+            "B" : [39, 40, 37, 38, 35, 36, 33, 34, 41, 42, 43, 44, 45, 46],
+            "C" : [23, 24, 21, 22, 19, 20, 17, 18, 25, 26, 27, 28, 29, 30],
+            "D" : [7, 8, 5, 6, 3, 4, 1, 2, 9, 10, 11, 12, 13, 14],
+        }
+        
+        self._channel_mapping = {
+            1: "7", 
+            2: "8",
+            3: "5", 
+            4: "6",
+            5: "3", 
+            6: "4",
+            7: "1", 
+            8: "2",
+            9: "9", 
+            10: "10",
+            11: "11", 
+            12: "12",
+            13: "13", 
+            14: "14",
+            
+            17: "7", 
+            18: "8",
+            19: "5", 
+            20: "6",
+            21: "3", 
+            22: "4",
+            23: "1", 
+            24: "2",
+            25: "9", 
+            26: "10",
+            27: "11", 
+            28: "12",
+            29: "13", 
+            30: "14",
+            
+            33: "7", 
+            34: "8",
+            35: "5", 
+            36: "6",
+            37: "3", 
+            38: "4",
+            39: "1", 
+            40: "2",
+            41: "9", 
+            42: "10",
+            43: "11", 
+            44: "12",
+            45: "13", 
+            46: "14",
+            
+            49: "7", 
+            50: "8",
+            51: "5", 
+            52: "6",
+            53: "3", 
+            54: "4",
+            55: "1", 
+            56: "2",
+            57: "9", 
+            58: "10",
+            59: "11", 
+            60: "12",
+            61: "13", 
+            62: "14"
+        }
+                
+    @classmethod
+    def from_parent(cls, parent:IDevice) -> IDevice:
+        rlt = cls(parent.socket)
+        rlt.device_id = parent.device_id
+        rlt._device_no = parent.device_no
+        return rlt
+        
+    def init_edf_handler(self):
+        self._edf_handler = ARSKindlingEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
+        self._edf_handler.set_device_type(self.device_type)
+        self._edf_handler.set_device_no(self.device_no)
+        self._edf_handler.set_storage_path(self._storage_path)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'ARS')
+        logger.debug(f"EDF Handler initialized")
+        
+    # 设置采集参数
+    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+        self._acq_param["original_channels"] = channels
+        
+        # 根据映射关系做通道转换
+        for k in channels.keys():
+            if isinstance(channels[k], list):
+                temp = [k + str(i) for i in channels[k]]
+                channels[k] = [self.channel_mapping.get(c, 1) for c in temp]
+            else:
+                channels[k] = [k + str(channels[k])]
+                
+                
+        # 更新采集参数        
+        self._acq_param["channels"] = channels 
+        self._acq_param["sample_rate"] = sample_rate
+        self._acq_param["sample_range"] = sample_range
+        self._acq_channels = channels
+        self._sample_rate = sample_rate
+        self._sample_range = sample_range     
+    
+    # 设置阻抗通道
+    # {'A': [1,2,3], 'B':[1,2,3]}
+    def set_impedance_channels(self, channels):
+        
+        arr = []
+        
+        # 根据映射关系做通道转换
+        for k in channels.keys():
+            if isinstance(channels[k], list):
+                temp = [k + str(i) for i in channels[k]]
+                arr += [self.channel_mapping.get(c, 1) for c in temp]
+            else:
+                arr += [k + str(channels[k])]
+                
+        self._impedance_channels = arr
+        
+    @property
+    def acq_channels(self):
+        if self._acq_channels is None:
+            self._acq_channels = [i for i in range(1, 63)]
+            
+        arr = []
+        for k in self._acq_channels.keys():
+            arr = list(arr + self._acq_channels[k])
+            
+        return list(set(arr))    
+    
+    def _produce_impedance(self, body: bytes):
+        # 分发阻抗数据包给订阅者
+        if len(self._impedance_consumer) > 0:
+            packet = self._impedance_wrapper(body)
+            real_data = self.__impedance_transfer(packet)
+            for topic, q in self._impedance_consumer.items():
+                try:
+                    # 队列满了就丢弃最早的数据
+                    if q.full(): 
+                        q.get()
+                    q.put(real_data, timeout=1)
+                except Exception as e:
+                    logger.error(f"impedance data put to queue exception: {str(e)}")
+                    
+    def _produce_signal(self, body: bytes):        
+        
+        # 处理信号数据
+        data = self._signal_wrapper(body)  
+        # logger.debug("pkg_id: {}, eeg len: {}".format(data.pkg_id, len(data.eeg)))
+        
+        trigger_positions = [index for index, value in enumerate(data.trigger) if value != 0]
+        if len(trigger_positions) > 0:
+            # logger.debug(f"Trigger触发点位置: {trigger_positions}, 触发点时间戳: {[data.time_stamp + int(pos * 1000 / data.sample_rate) for pos in trigger_positions]}")
+            for pos in trigger_positions:
+                self.trigger(self.trigger_info(data.trigger[pos]))
+        
+        if len(self.signal_consumers) > 0 :
+            # 信号数字值转物理值
+            data.eeg_p = self.eeg2phy(np.array(data.eeg))        
+        
+        real_data = self.__signal_transfer(data)   
+               
+        # 存储
+        if self.storage_enable:            
+            # 确保记录线程启动
+            if self._recording is False:
+                self._start_recording() 
+                
+            # 写入文件的缓存队列
+            if self._signal_cache is None:
+                self._signal_cache = Queue(1000000)  # 缓冲队列
+            self._signal_cache.put(real_data)
+                                    
+        if len(self.signal_consumers) > 0 :
+            # 订阅只返回物理值
+            real_data.eeg = real_data.eeg_p
+            # 发送数据包到订阅者
+            for q in list(self.signal_consumers.values()):
+                # 队列满了就丢弃最早的数据
+                if q.full(): 
+                    q.get()
+                    
+                q.put(real_data)      
+     
+    # 信号数据转换
+    def __impedance_transfer(self, packet: ImpedancePacket):
+        channels = {}
+        impedance = {}
+        #按分区拆分数据格式
+        for k in self._channel_spilt.keys():      
+            logger.trace(f'分区{k}的阻抗数据')   
+            c, d, p = self.__packet_filter(packet, self._channel_spilt[k], type='impedance')
+            if c is not None:
+                channels[k] = c
+                impedance[k] = d
+        packet.channels = channels
+        packet.impedance = impedance
+            
+        return packet
+      
+    # 信号数据转换
+    def __signal_transfer(self, packet: RscPacket):
+        channels = {}
+        eeg = {}
+        eeg_p = {}
+        #按分区拆分数据格式
+        for k in self._channel_spilt.keys():      
+            logger.trace(f'分区{k}, {self._channel_spilt[k]}')   
+            c, d, p = self.__packet_filter(packet, self._channel_spilt[k])
+            if c is not None:
+                channels[k] = c
+                eeg[k] = d
+            if p is not None:
+                eeg_p[k] = p
+        packet.channels = channels
+        packet.eeg = eeg
+        #物理值
+        if packet.eeg_p is not None:
+            packet.eeg_p = eeg_p
+            
+        return packet
+    
+    def __packet_filter(self, packet, channel_filter=None, type:Literal['signal','impedance']='signal'):
+        # 参数检查
+        if packet is None or channel_filter is None:
+            logger.warning("空数据，忽略")
+            return None, None, None
+        
+        channel_pos = get_sorted_indices_basic(packet.channels, channel_filter)
+        
+        if channel_pos is None or len(channel_pos) == 0 :
+            logger.trace(f"没有指定分区的通道，跳过")
+            return None, None, None
+        
+        # 分区数据包写入
+        
+        # 保留本分区的通道和数据
+        channels = [packet.channels[p] for p in channel_pos]
+        
+        #阻抗数据
+        if type == 'impedance':
+            impedance = [packet.impedance[p] for p in channel_pos]
+            return [self._channel_mapping.get(channel_id, []) for channel_id in channels], impedance, None
+        
+        # 信号数据
+        eeg = [packet.eeg[p] for p in channel_pos]
+        eeg_p = None
+        if packet.eeg_p is not None:
+            eeg_p = [packet.eeg_p[p] for p in channel_pos]
+        
+        return [self._channel_mapping.get(channel_id, []) for channel_id in channels], eeg, eeg_p
+        
+    
+    

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/rsc/device/base.py

@@ -8,11 +8,27 @@ import numpy as np
 from qlsdk.core.entity import RscPacket, ImpedancePacket
 from qlsdk.core.utils import to_bytes
 from qlsdk.rsc.interface import IDevice, IParser
-from qlsdk.rsc.command import StartImpedanceCommand, StopImpedanceCommand, StartStimulationCommand, StopStimulationCommand, SetAcquisitionParamCommand, StartAcquisitionCommand, StopAcquisitionCommand
+from qlsdk.rsc.command import SetImpedanceParamCommand, StartImpedanceCommand, StopImpedanceCommand, StartStimulationCommand, StopStimulationCommand, SetAcquisitionParamCommand, StartAcquisitionCommand, StopAcquisitionCommand
 from qlsdk.rsc.paradigm import StimulationParadigm
 from qlsdk.rsc.parser.base import TcpMessageParser
 
+    
+def intersection_positions(A, B):
+    setB = set(B)
+    seen = set()
+    return [idx for idx, elem in enumerate(A) 
+            if elem in setB and elem not in seen and not seen.add(elem)]    
+    
 class QLBaseDevice(IDevice):
+    
+    __TRIGGER_MAPPING = {
+        0x3E8: "Start of stimulation",
+        0x3E9: "End of stimulation",
+        0x3EA: "Ascending end of stimulation",
+        0x3EB: "Descending start of stimulation ",
+        0x3EC: "刺激参数有误",
+        0x3ED: "End of stimulation (by force)",
+    }    
     def __init__(self, socket):
         self.socket = socket
         
@@ -62,35 +78,9 @@ class QLBaseDevice(IDevice):
             "channels": [],
         }
         
-        self._stim_param = {
-            "stim_type": 0,                 # 刺激类型：0-所有通道参数相同, 1: 通道参数不同
-            "channels": [],
-            "param": [{
-                    "channel_id": 0,        #通道号 从0开始                          -- 必填
-                    "waveform": 3,          #波形类型：0-直流，1-交流 2-方波 3-脉冲   -- 必填
-                    "current": 1,           #电流强度(mA)                            -- 必填
-                    "duration": 30,         #平稳阶段持续时间(s)                      -- 必填
-                    "ramp_up": 5,           #上升时间(s) 默认0
-                    "ramp_down": 5,         #下降时间(s) 默认0
-                    "frequency": 500,       #频率(Hz) -- 非直流必填
-                    "phase_position": 0,    #相位 -- 默认0
-                    "duration_delay": "0",  #延迟启动时间(s) -- 默认0
-                    "pulse_width": 0,       #脉冲宽度(us) -- 仅脉冲类型电流有效， 默认100us
-                },
-                {
-                    "channel_id": 1,        #通道号 从0开始                          -- 必填
-                    "waveform": 3,          #波形类型：0-直流，1-交流 2-方波 3-脉冲   -- 必填
-                    "current": 1,           #电流强度(mA)                            -- 必填
-                    "duration": 30,         #平稳阶段持续时间(s)                      -- 必填
-                    "ramp_up": 5,           #上升时间(s) 默认0
-                    "ramp_down": 5,         #下降时间(s) 默认0
-                    "frequency": 500,       #频率(Hz) -- 非直流必填
-                    "phase_position": 0,    #相位 -- 默认0
-                    "duration_delay": "0",  #延迟启动时间(s) -- 默认0
-                    "pulse_width": 0,       #脉冲宽度(us) -- 仅脉冲类型电流有效， 默认100us
-                }
-            ]
-        }
+        self._stim_param = None
+        
+        self._impedance_channels = []
         
         self.stim_paradigm: StimulationParadigm = None
         # 信号采集状态
@@ -116,6 +106,7 @@ class QLBaseDevice(IDevice):
         self._signal_cache: Queue = None
         self._recording = False
         
+        
     def parser(self) -> IParser:
         return self._parser
     
@@ -132,11 +123,14 @@ class QLBaseDevice(IDevice):
             self._produce_impedance(body)       
         
     def _produce_impedance(self, body: bytes):
-        packet = ImpedancePacket.transfer(body)
         # 分发阻抗数据包给订阅者
         if len(self._impedance_consumer) > 0:
+            packet = self._impedance_wrapper(body)
             for topic, q in self._impedance_consumer.items():
                 try:
+                    # 队列满了就丢弃最早的数据
+                    if q.full(): 
+                        q.get()
                     q.put(packet, timeout=1)
                 except Exception as e:
                     logger.error(f"impedance data put to queue exception: {str(e)}")
@@ -151,7 +145,7 @@ class QLBaseDevice(IDevice):
         if len(trigger_positions) > 0:
             # logger.debug(f"Trigger触发点位置: {trigger_positions}, 触发点时间戳: {[data.time_stamp + int(pos * 1000 / data.sample_rate) for pos in trigger_positions]}")
             for pos in trigger_positions:
-                self.trigger(trigger_info(data.trigger[pos]))
+                self.trigger(self.trigger_info(data.trigger[pos]))
         # 存储
         if self.storage_enable:            
             # 确保记录线程启动
@@ -175,7 +169,17 @@ class QLBaseDevice(IDevice):
                 if q.full(): 
                     q.get()
                     
-                q.put(data)        
+                q.put(data)    
+                
+    def _impedance_wrapper(self, body: bytes):        
+        packet = ImpedancePacket().transfer(body)    
+        if self._impedance_channels is not None and len(self._impedance_channels) > 0:
+            # 只保留设置的阻抗通道
+            channel_pos = intersection_positions(packet.channels, self._impedance_channels)
+            packet.impedance = [packet.impedance[i] for i in channel_pos]
+            packet.channels = [packet.channels[i] for i in channel_pos]
+            
+        return packet
                 
     # 信号数据转换
     def _signal_wrapper(self, body: bytes):
@@ -249,6 +253,12 @@ class QLBaseDevice(IDevice):
     def device_type(self) -> int:
         return self._device_type
     
+    def set_impedance_channels(self, channels):
+        self._impedance_channels = channels
+        
+    def get_impedance_channels(self): 
+        return self._impedance_channels    
+    
     def start_message_parser(self) -> None:
         self._parser = TcpMessageParser(self)
         self._parser.start()
@@ -384,9 +394,17 @@ class QLBaseDevice(IDevice):
         
     def start_impedance(self):
         logger.info(f"[设备-{self.device_no}]启动阻抗测量")  
-        msg = StartImpedanceCommand.build(self).pack()
-        logger.trace(f"start_impedance message is {msg.hex()}")
-        self.socket.sendall(msg)
+        # 设置数据采集参数
+        # set_param_msg = SetImpedanceParamCommand.build(self).pack()
+        device_id = bytes.fromhex(self.device_id)[::-1].hex() if self.device_id else '00000000'
+        set_param_msg = bytes.fromhex(f'5aa50239{device_id}3f0000001104ffffffffffffffff000000000000000000000000000000000000000000000000e8030000fa00000010000164000000745c5aa50239390045243a00000012040000000000000000000000000000000000000000000000000000000000000000000001000000000000004c2a')
+        logger.debug(f"set_param_msg message is {set_param_msg.hex()}")
+        self.socket.sendall(set_param_msg)
+        sleep(0.5)
+    
+        impedance_start_msg = StartImpedanceCommand.build(self).pack()
+        logger.debug(f"start_impedance message is {impedance_start_msg.hex()}")
+        self.socket.sendall(impedance_start_msg)
     
     def stop_impedance(self):
         logger.info(f"[设备{self.device_no}]停止阻抗测量")  
@@ -490,6 +508,7 @@ class QLBaseDevice(IDevice):
         else:
             logger.info("已关闭文件记录，不会记录trigger信息")
         
+    # 设置信号采集参数
     def gen_set_acquirement_param(self) -> bytes:
         
         body = to_bytes(self.acq_channels) 
@@ -500,7 +519,19 @@ class QLBaseDevice(IDevice):
         body += bytes.fromhex('00')     
         
         return body
-    
+    # 设置阻抗测量参数
+    def gen_set_impedance_param(self) -> bytes:
+        
+        # 仅通道生效 32字节，其他不生效-272字节，实际73字节
+        body = to_bytes(self._impedance_channels) 
+        # 100 bytes
+        # body += bytes.fromhex('00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')     
+        # # 100 bytes
+        # body += bytes.fromhex('00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')     
+        # 73 bytes
+        body += bytes.fromhex('00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')     
+        
+        return bytes.fromhex('ffffffffffffffff000000000000000000000000000000000000000000000000e8030000fa00000010000164000000745c5aa50239390045243a0000001204000000000000000000000000000000000000000000000000000000000000000000000100000000000000')
     def disconnect(self):
         logger.info(f"[断开设备-{self.device_no}]的连接...")  
         self._listening = False
@@ -517,6 +548,9 @@ class QLBaseDevice(IDevice):
         
     def enable_storage(self, enable: bool = True):
         self.storage_enable = enable
+        
+    def trigger_info(self, code: int) -> str:
+        return QLBaseDevice.__TRIGGER_MAPPING.get(code, hex(code))    
     
     def __str__(self):
         return f''' 
@@ -537,15 +571,4 @@ class QLBaseDevice(IDevice):
         return self.device_type == other.device_type and self.device_no == other.device_no
 
     def __hash__(self):
-        return hash((self.device_type, self.device_no))    
-    
-__TRIGGER_MAPPING = {
-    0x3E8: "Start of stimulation",
-    0x3E9: "End of stimulation",
-    0x3EA: "Ascending end of stimulation",
-    0x3EB: "Descending start of stimulation ",
-    0x3EC: "刺激参数有误",
-    0x3ED: "End of stimulation (by force)",
-}    
-def trigger_info(code: int) -> str:
-    return __TRIGGER_MAPPING.get(code, "未知触发事件")    
+        return hash((self.device_type, self.device_no))    

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/rsc/interface/device.py

@@ -24,6 +24,10 @@ class  IDevice(ABC):
     @property
     def device_no(self) -> str:
         pass
+       
+    def set_impedance_channels(self):
+        raise NotImplementedError("Not Supported")
+        
     
     def read_msg(self, size: int) -> bytes:
         raise NotImplementedError("Not Supported")
@@ -69,4 +73,13 @@ class  IDevice(ABC):
         pass
     
     def enable_storage(self, enable: bool = True):
-        pass
+        pass
+    
+    def set_impedance_channel(self):
+        raise NotImplementedError("Not Supported")
+    
+    def start_impedance(self):
+        raise NotImplementedError("Not Supported")
+    
+    def stop_impedance(self):
+        raise NotImplementedError("Not Supported")

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/rsc/paradigm.py

@@ -191,7 +191,8 @@ class ACStimulation(StimulationChannel):
         self.frequency = frequency
         # self.frequency = frequency
         self.phase_position = phase_position
-    
+        if current < 0:
+            self.phase_position = (phase_position + 180) % 360
     def to_json(self):
         return {
             "channel_id": self.channel_id,

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk/rsc/parser/base.py

@@ -53,7 +53,7 @@ class TcpMessageParser(IParser):
                 buf_len = get_len(self.buffer)
                 
                 if buf_len < self.header_len:
-                    logger.trace(f"等待数据中...: expect: {self.header_len}, actual: {buf_len}")
+                    # logger.trace(f"等待数据中...: expect: {self.header_len}, actual: {buf_len}")
                     if not self.__fill_from_cache():
                         time.sleep(0.1)
                         continue
@@ -64,7 +64,7 @@ class TcpMessageParser(IParser):
                 start_pos = self.buffer.tell()
                 head = self.buffer.read(2)
                 if head != self.header:
-                    logger.trace(f"数据包头部不匹配: {head.hex()}, 期望: {self.header.hex()},继续查找...")
+                    # logger.trace(f"数据包头部不匹配: {head.hex()}, 期望: {self.header.hex()},继续查找...")
                     self.buffer.seek(start_pos + 1)  # 移动到下一个字节
                     continue
                 

{qlsdk2-0.6.0a9 → qlsdk2-0.6.0a12}/src/qlsdk2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qlsdk2
-Version: 0.6.0a9
+Version: 0.6.0a12
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun

qlsdk2-0.6.0a9/src/qlsdk/rsc/device/arskindling.py

@@ -1,80 +0,0 @@
-from loguru import logger
-from qlsdk.persist import ARSKindlingEDFHandler
-from qlsdk.rsc.interface import IDevice
-from qlsdk.rsc.command import *
-from qlsdk.rsc.device.base import QLBaseDevice
-
-class ARSKindling(QLBaseDevice):
-    
-    device_type = 0x60 # C64RS设备类型标识符
-    
-    def __init__(self, socket):
-        super().__init__(socket)
-        
-        self.channel_mapping = {
-            "A1": 55, "A2": 56, "A3": 53, "A4": 54, "A5": 51, "A6": 52, "A7": 49, "A8": 50,
-            "A9": 57, "A10": 58, "A11": 59, "A12": 60, "A13": 61, "A14": 62, 
-            
-            "B1": 39, "B2": 40,  "B3": 37, "B4": 38, "B5": 35, "B6": 36, "B7": 33, "B8": 34,
-            "B9": 41, "B10": 42, "B11": 43, "B12": 44, "B13": 45, "B14": 46, 
-            
-            "C1": 23, "C2": 24, "C3": 21, "C4": 22, "C5": 19, "C6": 20, "C7": 17, "C8": 18,
-            "C9": 25, "C10": 26, "C11": 27, "C12": 28, "C13": 29, "C14": 30, 
-            
-            "D1": 7, "D2": 8, "D3": 5, "D4": 6, "D5": 3, "D6": 4, "D7": 1, "D8": 2,
-            "D9": 9, "D10": 10, "D11": 11, "D12": 12, "D13": 13, "D14": 14, 
-        }
-        
-    @classmethod
-    def from_parent(cls, parent:IDevice) -> IDevice:
-        rlt = cls(parent.socket)
-        rlt.device_id = parent.device_id
-        rlt._device_no = parent.device_no
-        return rlt
-        
-    def init_edf_handler(self):
-        self._edf_handler = ARSKindlingEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
-        self._edf_handler.set_device_type(self.device_type)
-        self._edf_handler.set_device_no(self.device_no)
-        self._edf_handler.set_storage_path(self._storage_path)
-        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'ARS')
-        logger.debug(f"EDF Handler initialized")
-        
-    # 设置采集参数
-    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
-        self._acq_param["original_channels"] = channels
-        
-        # 根据映射关系做通道转换
-        for k in channels.keys():
-            if isinstance(channels[k], list):
-                temp = [k + str(i) for i in channels[k]]
-                channels[k] = [self.channel_mapping.get(c, 1) for c in temp]
-            else:
-                channels[k] = [k + str(channels[k])]
-                
-                
-        # 更新采集参数        
-        self._acq_param["channels"] = channels 
-        self._acq_param["sample_rate"] = sample_rate
-        self._acq_param["sample_range"] = sample_range
-        self._acq_channels = channels
-        self._sample_rate = sample_rate
-        self._sample_range = sample_range     
-    
-    def gen_set_acquirement_param(self) -> bytes:
-        
-        arr = []
-        for k in self.acq_channels.keys():
-            arr = list(arr + self.acq_channels[k])
-            
-        arr = list(set(arr))
-        body = to_bytes(arr) 
-        body += self.sample_range.to_bytes(4, byteorder='little')
-        body += self.sample_rate.to_bytes(4, byteorder='little')
-        body += self.sample_num.to_bytes(4, byteorder='little')
-        body += self.resolution.to_bytes(1, byteorder='little')
-        body += bytes.fromhex('00')     
-        
-        return body
-    
-