qlsdk2 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

qlsdk/persist/rsc_edf.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+import time
 from multiprocessing import Lock, Queue
 from time import time_ns
 from pyedflib import FILETYPE_BDFPLUS, FILETYPE_EDFPLUS, EdfWriter
@@ -77,8 +78,9 @@ class EDFStreamWriter(Thread):
         if self._writer is None:
             self._init_writer()
             
-        while True:
-            if self._recording or (not self.data_queue.empty()):
+        waits = 300
+        while waits > 0:
+            if not self.data_queue.empty():
                 try:
                     data = self.data_queue.get(timeout=30)
                     if data is None:
@@ -88,13 +90,20 @@ class EDFStreamWriter(Thread):
                     self._points += len(data[1])
                     logger.trace(f"已处理数据点数：{self._points}")
                     self._write_file(data)
+                    # 有数据重置计数器
+                    waits = 100  # 重置等待计数器
                 except Exception as e:
                     logger.error(f"异常或超时(30s)结束: {str(e)}")
                     break
             else:
-                logger.debug("数据记录完成")
-                break
+                time.sleep(0.1)
+                # 记录状态等待30s、非记录状态等待3s
+                if self._recording:
+                    waits -= 1
+                else:
+                    waits -= 10
             
+        logger.info(f"数据记录完成：{self.file_path}")
         self.close()
         
     def _init_writer(self):
@@ -159,6 +168,9 @@ class EDFStreamWriter(Thread):
         # 写入时转置为(样本数, 通道数)格式
         self._writer.writeSamples(data_float64)
         self._duration += 1
+        
+        if self._duration % 10 == 0:  # 每10秒打印一次进度
+            logger.info(f"数据记录中... 文件名：{self.file_path}, 已记录时长: {self._duration}秒")
 
 # 用作数据结构一致化处理，通过调用公共类写入edf文件
 # 入参包含写入edf的全部前置参数
@@ -243,6 +255,8 @@ class RscEDFHandler(object):
             self._device_type = "LJ64S1"
         elif device_type == 0x60:
             self._device_type = "ARSKindling"
+        elif device_type == 0x339:
+            self._device_type = "C16R"
         else:
             self._device_type = device_type
         
@@ -264,17 +278,18 @@ class RscEDFHandler(object):
     def write(self, packet: RscPacket):
         # logger.trace(f"packet: {packet}")    
         if packet is None:
+            logger.info(f"收到结束信号，即将停止写入数据:{self.file_name}")
             self._edf_writer_thread.stop_recording()
             return
     
         with self._lock:
             if self.channels is None:
-                logger.info(f"开始记录数据到文件...")
+                logger.debug(f"开始记录数据到文件...")
                 self.channels = packet.channels
                 self._first_pkg_id = packet.pkg_id if self._first_pkg_id is None else self._first_pkg_id
                 self._first_timestamp = packet.time_stamp if self._first_timestamp is None else self._first_timestamp
                 self._start_time = datetime.now()
-                logger.info(f"第一个包id: {self._first_pkg_id }, 时间戳:{self._first_timestamp}， 当前时间:{datetime.now().timestamp()}  offset: {datetime.now().timestamp() - self._first_timestamp}")
+                logger.debug(f"第一个包id: {self._first_pkg_id }, 时间戳:{self._first_timestamp}， 当前时间:{datetime.now().timestamp()}  offset: {datetime.now().timestamp() - self._first_timestamp}")
                 
             if self._last_pkg_id and self._last_pkg_id != packet.pkg_id - 1:  
                 self._lost_packets += packet.pkg_id - self._last_pkg_id - 1

qlsdk/rsc/command/__init__.py

@@ -51,15 +51,29 @@ class DeviceCommand(abc.ABC):
         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
         
-        """构建消息头"""
-        return (
-            DeviceCommand.HEADER_PREFIX
-            + int(2).to_bytes(1, 'little')     # pkgType  
-            + device_type.to_bytes(1, 'little')
-            + device_id.to_bytes(4, 'little')
-            + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
-            + self.cmd_code.to_bytes(2, 'little')
-        )
+        #兼容设计
+        b_device_type = None
+        if device_type > 0xFF:
+            b_device_type = int.to_bytes(device_type, 2, 'little')
+        
+        if b_device_type is None:
+            return (
+                DeviceCommand.HEADER_PREFIX
+                + int(2).to_bytes(1, 'little')     # pkgType  
+                + device_type.to_bytes(1, 'little')
+                + device_id.to_bytes(4, 'little')
+                + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
+                + self.cmd_code.to_bytes(2, 'little')
+            )
+        else:
+            return (
+                DeviceCommand.HEADER_PREFIX
+                + b_device_type[0].to_bytes(1, 'little')     # pkgType  
+                + b_device_type[1].to_bytes(1, 'little')
+                + device_id.to_bytes(4, 'little')
+                + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
+                + self.cmd_code.to_bytes(2, 'little')
+            )
     
     def unpack(self, payload: bytes) -> bytes:
         """解析消息体"""
@@ -70,7 +84,7 @@ class DeviceCommand(abc.ABC):
         time = int.from_bytes(body[0:8], 'little')
         # result - 1B
         result = body[8]
-        logger.info(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
+        logger.debug(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
         
     
 
@@ -294,18 +308,8 @@ class SignalDataCommand(DeviceCommand):
         # 解析数据包
         packet = RscPacket()
         packet.transfer(body)  
-        
-        # 文件写入到edf
-        if self.device.edf_handler:
-            self.device.edf_handler.write(packet)
-                        
-        if len(self.device.signal_consumers) > 0 :
-            # 信号数字值转物理值
-            packet.eeg = self.device.eeg2phy(np.array(packet.eeg))
-            
-            # 发送数据包到订阅者
-            for q in list(self.device.signal_consumers.values()):
-                q.put(packet)
+        # 将数据包传递给设备
+        self.device.produce(packet)
                 
             
 

qlsdk/rsc/device/__init__.py

@@ -1,2 +1,7 @@
 from .base import QLBaseDevice
-from .device_factory import DeviceFactory
+from .device_factory import DeviceFactory
+
+# import devices
+from .c64_rs import C64RS
+from .c16_rs import C16RS
+from .arskindling import ARSKindling

qlsdk/rsc/device/arskindling.py

@@ -167,7 +167,7 @@ class ARSKindling(QLBaseDevice):
         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)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'ARS')
         
     @property
     def edf_handler(self):
@@ -233,6 +233,8 @@ class ARSKindling(QLBaseDevice):
     # 设置采集参数
     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]]
@@ -241,7 +243,7 @@ class ARSKindling(QLBaseDevice):
                 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

qlsdk/rsc/device/base.py

@@ -5,12 +5,13 @@ from time import sleep, time_ns
 from typing import Any, Dict, Literal
 
 from loguru import logger
+import numpy as np
+from qlsdk.core.entity import RscPacket
 from qlsdk.core.utils import to_bytes
 from qlsdk.persist import RscEDFHandler
 from qlsdk.rsc.interface import IDevice, IParser
 from qlsdk.rsc.parser import TcpMessageParser
 from qlsdk.rsc.command import StartImpedanceCommand, StopImpedanceCommand, StartStimulationCommand, StopStimulationCommand, SetAcquisitionParamCommand, StartAcquisitionCommand, StopAcquisitionCommand
-# from qlsdk.rsc.command import *
 
 class QLBaseDevice(IDevice):
     def __init__(self, socket):
@@ -117,8 +118,8 @@ class QLBaseDevice(IDevice):
         # 存储目录
         
         # 
-        self.__signal_consumer: Dict[str, Queue[Any]]={}
-        self.__impedance_consumer: Dict[str, Queue[Any]]={}
+        self._signal_consumer: Dict[str, Queue[Any]]={}
+        self._impedance_consumer: Dict[str, Queue[Any]]={}
         
         # EDF文件处理器
         self._edf_handler = None       
@@ -128,6 +129,38 @@ class QLBaseDevice(IDevice):
         
     def parser(self) -> IParser:
         return self._parser
+    
+    # 数据包处理
+    def produce(self, data: RscPacket):
+        if data is None: return     
+        
+        # 处理信号数据
+        self._signal_wrapper(data)   
+        
+        # 存储
+        if self.storage_enable:
+            self._write_signal(data)
+                        
+        if len(self.signal_consumers) > 0 :
+            # 信号数字值转物理值
+            data.eeg = self.eeg2phy(np.array(data.eeg))
+            
+            # 发送数据包到订阅者
+            for q in list(self.signal_consumers.values()):
+                q.put(data)
+                
+    # 信号数据转换(默认不处理)
+    def _signal_wrapper(self, data: RscPacket):
+        pass
+                
+    def _write_signal(self, data: RscPacket):
+        # 文件写入到edf
+        if self._edf_handler is None:
+            logger.debug("Initializing EDF handler for data storage")
+            self.init_edf_handler()
+        
+        if self._edf_handler:  
+            self._edf_handler.write(data)
         
     def start_listening(self):        
         
@@ -142,7 +175,7 @@ class QLBaseDevice(IDevice):
         return True
     
     def stop_listening(self):
-        logger.info(f"设备{self.device_no}停止socket监听")
+        logger.trace(f"设备{self.device_no}停止socket监听")
         self._listening = False
         
     @property
@@ -152,15 +185,15 @@ class QLBaseDevice(IDevice):
     def start_message_parser(self) -> None:
         self._parser = TcpMessageParser(self)
         self._parser.start()
-        logger.info("TCP消息解析器已启动")
+        logger.debug("TCP消息解析器已启动")
     
     def start_message_listening(self) -> None:
         def _accept():
             while self._listening:
-                # 缓冲去4M
+                # 缓冲区4M
                 data = self.socket.recv(4096*1024)
                 if not data:
-                    logger.warning(f"设备{self.device_name}连接结束")
+                    logger.warning(f"设备[{self.device_name}]连接结束")
                     break
                 
                 self._parser.append(data)
@@ -169,7 +202,7 @@ class QLBaseDevice(IDevice):
         self._listening = True
         message_accept = Thread(target=_accept, daemon=True)
         message_accept.start()
-        logger.info(f"socket消息监听已启动")
+        logger.debug(f"socket消息监听已启动")
         
     def set_device_type(self, type: int):
         self._device_type = type
@@ -206,6 +239,7 @@ class QLBaseDevice(IDevice):
         return self._digital_range
     
     def init_edf_handler(self):
+        logger.warning("init_edf_handler not implemented in base class, should be overridden in subclass")
         pass
     #     self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
     #     self._edf_handler.set_device_type(self.device_type)
@@ -221,6 +255,7 @@ class QLBaseDevice(IDevice):
     @property
     def edf_handler(self):
         if not self.storage_enable:
+            logger.warning("EDF storage is disabled, no edf handler available")
             return None
         
         if self._edf_handler is None:
@@ -247,11 +282,11 @@ class QLBaseDevice(IDevice):
         return 10
     @property
     def signal_consumers(self):
-        return self.__signal_consumer
+        return self._signal_consumer
     
     @property
     def impedance_consumers(self):
-        return self.__impedance_consumer
+        return self._impedance_consumer
     
     # 设置记录文件路径
     def set_storage_path(self, path):
@@ -283,26 +318,26 @@ class QLBaseDevice(IDevice):
         pass      
         
     def start_impedance(self):
-        logger.info("启动阻抗测量")  
+        logger.info(f"[设备-{self.device_no}]启动阻抗测量")  
         msg = StartImpedanceCommand.build(self).pack()
-        logger.debug(f"start_impedance message is {msg.hex()}")
+        logger.trace(f"start_impedance message is {msg.hex()}")
         self.socket.sendall(msg)
     
     def stop_impedance(self):
-        logger.info("停止阻抗测量")  
+        logger.info(f"[设备{self.device_no}]停止阻抗测量")  
         msg = StopImpedanceCommand.build(self).pack()
-        logger.debug(f"stop_impedance message is {msg.hex()}")
+        logger.trace(f"stop_impedance message is {msg.hex()}")
         self.socket.sendall(msg)
     
     def start_stimulation(self):
         if self.stim_paradigm is None:
             logger.warning("刺激参数未设置，请先设置刺激参数")
             return
-        logger.info("启动电刺激")  
+        logger.info(f"[设备-{self.device_no}]启动电刺激")  
         msg = StartStimulationCommand.build(self).pack()
-        logger.debug(f"start_stimulation message is {msg.hex()}")
+        logger.trace(f"start_stimulation message is {msg.hex()}")
         self.socket.sendall(msg)
-        t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,))
+        t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,), daemon=True)
         t.start()
         
     def _stop_stimulation_trigger(self, duration):
@@ -310,67 +345,74 @@ class QLBaseDevice(IDevice):
         while delay > 0:
             sleep(1)
             delay -= 1
-        logger.info(f"_stop_stimulation_trigger duration: {duration}")
+        logger.debug(f"_stop_stimulation_trigger duration: {duration}")
         if self._edf_handler:
             self._edf_handler.trigger("stimulation should be stopped")
         else:
             logger.warning("stop stim trigger fail. no edf writer alive")
         
     def stop_stimulation(self):
-        logger.info("停止电刺激")  
+        logger.info(f"[设备-{self.device_no}]停止电刺激")  
         msg = StopStimulationCommand.pack()
-        logger.debug(f"stop_stimulation message is {msg.hex()}")
+        logger.trace(f"stop_stimulation message is {msg.hex()}")
         self.socket.sendall(msg)
         
     # 启动采集
     def start_acquisition(self, recording = True):
-        logger.info("启动信号采集")  
+        logger.info(f"[设备-{self.device_no}]启动信号采集")  
         self._recording = recording
+        # 初始化EDF处理器
+        self.init_edf_handler()
         # 设置数据采集参数
         param_bytes = SetAcquisitionParamCommand.build(self).pack()
         # 启动数据采集
         start_bytes = StartAcquisitionCommand.build(self).pack()
         msg = param_bytes + start_bytes
-        logger.debug(f"start_acquisition message is {msg.hex()}")
+        logger.trace(f"start_acquisition message is {msg.hex()}")
         self.socket.sendall(msg)
         
     # 停止采集
     def stop_acquisition(self):
-        logger.info("停止信号采集")  
+        logger.info(f"[设备-{self.device_no}]停止信号采集")  
         msg = StopAcquisitionCommand.build(self).pack()
-        logger.debug(f"stop_acquisition message is {msg.hex()}")
+        logger.trace(f"stop_acquisition message is {msg.hex()}")
         self.socket.sendall(msg)
         if self._edf_handler:
             # 发送结束标识
             self.edf_handler.write(None)
         
-    # 订阅实时数据
+    '''
+        订阅数据
+        topic: 订阅主题
+        q: 数据队列
+        type: 数据类型，signal-信号数据，impedance-阻抗数据
+    '''
     def subscribe(self, topic:str=None, q : Queue=None, type : Literal["signal","impedance"]="signal"):  
             
-        logger.info(f"base订阅{self.device_name}的数据流")    
-        # 数据队列
+        # 队列名称     
+        if topic is None:
+            topic = f"{self.device_no}_{type}_{time_ns()}"
+            
+        logger.debug(f"[设备-{self.device_no}]订阅数据流： {topic}, type: {type}")    
+            
         # 数据队列
         if q is None:
             q = Queue(maxsize=1000)
-            
-        # 队列名称     
-        if topic is None:
-            topic = f"{type}_{time_ns()}"
         
         # 订阅生理电信号数据
         if type == "signal":
             # topic唯一，用来区分不同的订阅队列（下同）
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
+            if topic in list(self._signal_consumer.keys()):
+                logger.warning(f"已存在主题[{topic}]的信号数据订阅！")
             else:
-                self.__signal_consumer[topic] = q
+                self._signal_consumer[topic] = q
             
         # 订阅阻抗数据
         if type == "impedance":
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
+            if topic in list(self._impedance_consumer.keys()):
+                logger.warning(f"已存在主题[{topic}]的阻抗数据订阅！")
             else:
-                self.__impedance_consumer[topic] = q
+                self._impedance_consumer[topic] = q
             
         return topic, q
     
@@ -378,7 +420,7 @@ class QLBaseDevice(IDevice):
         if self._edf_handler:
             self.edf_handler.trigger(desc)
         else:
-            logger.warning("no edf handler, no place to recording trigger")
+            logger.warning("没有开启文件记录时，无法记录trigger信息")
         
     def gen_set_acquirement_param(self) -> bytes:
         

qlsdk/rsc/device/c16_rs.py

@@ -0,0 +1,205 @@
+
+from multiprocessing import Queue
+from threading import Thread
+from time import sleep, time_ns
+from typing import Any, Dict, Literal
+
+from loguru import logger
+from qlsdk.persist import RscEDFHandler
+from qlsdk.rsc.device.device_factory import DeviceFactory
+from qlsdk.rsc.interface import IDevice
+from qlsdk.rsc.command import *
+from qlsdk.rsc.device.base import QLBaseDevice
+
+'''
+    C16RS设备类，继承自QLBaseDevice
+    提供设备特定的属性和方法，包括设备类型、采集参数设置、电刺激参
+'''
+class C16RS(QLBaseDevice):
+    
+    device_type = 0x339  # C16RS设备类型标识符
+    
+    def __init__(self, socket):
+        
+        super().__init__(socket)
+        # 存储通道反向映射位置值
+        self._reverse_ch_pos  = None        
+        self.channel_name_mapping = {
+            "FP1": 1, 
+            "FP2": 2, 
+            "C3": 3, 
+            "C4": 4, 
+            "O1": 5, 
+            "O2": 6, 
+            "CZ": 7, 
+            "T7": 8,
+            "T8": 9, 
+            "M1": 10, 
+            "M2": 11, 
+            "F3": 12, 
+            "F4": 13, 
+            "FZ": 14, 
+            "F7": 15, 
+            "F8": 16, 
+            "PZ": 17, 
+            "P3": 18, 
+            "P7": 19, 
+            "P4": 20, 
+            "P8": 21
+        }
+        
+        # self.channel_mapping = {
+        #     "1": 61, 
+        #     "2": 62, 
+        #     "3": 63, 
+        #     "4": 64, 
+        #     "5": 65, 
+        #     "6": 66, 
+        #     "7": 68, 
+        #     "8": 67,
+        #     "9": 53, 
+        #     "10": 54, 
+        #     "11": 55, 
+        #     "12": 57, 
+        #     "13": 59, 
+        #     "14": 58, 
+        #     "15": 60, 
+        #     "16": 56, 
+        #     "17": 26, 
+        #     "18": 25, 
+        #     "19": 24, 
+        #     "20": 23, 
+        #     "21": 22
+        # }        
+        
+        self.channel_mapping = {
+            "1": 2, 
+            "2": 3, 
+            "3": 27, 
+            "4": 31, 
+            "5": 60, 
+            "6": 61, 
+            "7": 25, 
+            "8": 29,
+            "9": 33, 
+            "10": 62, 
+            "11": 63, 
+            "12": 10, 
+            "13": 14, 
+            "14": 8, 
+            "15": 12, 
+            "16": 16, 
+            "17": 43, 
+            "18": 45, 
+            "19": 47, 
+            "20": 49, 
+            "21": 51
+        }
+        
+        self.channel_display_mapping = {
+            2: 1, 
+            3: 2, 
+            27: 3, 
+            31: 4, 
+            60: 5, 
+            61: 6, 
+            25: 7, 
+            29: 8,
+            33: 9, 
+            62: 10, 
+            63: 11, 
+            10: 12, 
+            14: 13, 
+            8: 14, 
+            12: 15, 
+            16: 16, 
+            43: 17, 
+            45: 18, 
+            47: 19, 
+            49: 20, 
+            51: 21
+        }
+    
+    
+    @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 = RscEDFHandler(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 'C16R')
+            
+    # 设置刺激参数
+    def set_stim_param(self, param):
+        self.stim_paradigm = param
+    
+    # 设置采集参数
+    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+        # 保存原始通道参数
+        self._acq_param["original_channels"] = channels
+        
+        # 名称转换为数字通道  
+        channels = [self.channel_name_mapping.get(str(i).upper(), i) for i in channels]
+        
+        # 根据映射关系做通道转换-没有映射的默认到第一个通道
+        # 先设置不存在的通道为-1，再把-1替换为第一个通道，避免第一个通道也不合法的情况
+        channels = [self.channel_mapping.get(str(i), -1) for i in channels]
+        channels = [i if i != -1 else channels[0] for i in channels]
+                
+        # 更新采集参数
+        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
+        
+        logger.debug(f"C16RS: set_acq_param: {self._acq_param}")   
+        
+        # 参数改变后，重置通道位置映射
+        self._reverse_ch_pos  = None  
+    
+    # 信号数据转换(默认不处理)
+    def _signal_wrapper(self, data: RscPacket):
+        if data is None:
+            return
+        # 根据映射关系做通道转换-（注意数据和通道的一致性）
+        # data.channels = [self.channel_display_mapping.get(i, i) for i in data.channels]
+        
+        # 升级为类变量，减少计算
+        if self._reverse_ch_pos is None:
+            self._reverse_ch_pos = map_indices(self._acq_param["channels"], data.channels)
+        
+        # 更新通道（数据）顺序和输入一致
+        data.channels = self._acq_param["original_channels"]
+        data.eeg = [data.eeg[i] for i in self._reverse_ch_pos]
+        
+        
+def map_indices(A, B):
+    """
+    
+    参数:
+        A: 源数组（无重复值）
+        B: 目标数组（无重复值）
+    
+    返回:
+        C: 与A长度相同的数组，元素为A中对应值在B中的索引（不存在则为-1）
+    """
+    # 创建B的值到索引的映射字典（O(n)操作）
+    b_map = {value: idx for idx, value in enumerate(B)}
+    
+    # 遍历A，获取每个元素在B中的位置（O(m)操作）
+    return [b_map.get(a, -1) for a in A]
+                
+    
+# Register the C16RS device with the DeviceFactory
+DeviceFactory.register(C16RS.device_type, C16RS) 
+    
+    

qlsdk/rsc/device/c256_rs.py

@@ -16,6 +16,7 @@ class C256RS(QLBaseDevice):
     device_type = 0x40  # C64RS设备类型标识符
     
     def __init__(self, socket):
+        super().__init__(socket)
         self.socket = socket
         
         self._id = None

qlsdk/rsc/device/c64_rs.py

@@ -16,6 +16,7 @@ class C64RS(QLBaseDevice):
     device_type = 0x39  # C64RS设备类型标识符
     
     def __init__(self, socket):
+        super().__init__(socket)
         self.socket = socket
         
         self._id = None
@@ -145,9 +146,9 @@ class C64RS(QLBaseDevice):
     def init_edf_handler(self):
         self._edf_handler = RscEDFHandler(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_name)
+        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)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C64RS')
         
     @property
     def edf_handler(self):

qlsdk/rsc/device/c64s1.py

@@ -16,6 +16,7 @@ class C64S1(QLBaseDevice):
     device_type = 0x40  # C64RS设备类型标识符
     
     def __init__(self, socket):
+        super().__init__(socket)
         self.socket = socket
         
         self._id = None
@@ -151,9 +152,9 @@ class C64S1(QLBaseDevice):
     def init_edf_handler(self):
         self._edf_handler = RscEDFHandler(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_name)
+        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)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C64S1')
         
     @property
     def edf_handler(self):

qlsdk/rsc/device/device_factory.py

@@ -26,6 +26,7 @@ class DeviceFactory(object):
 
 # Register the C64RS device with the DeviceFactory    
 DeviceFactory.register(C64RS.device_type, C64RS)
+# Register the ARSKindling device with the DeviceFactory
 DeviceFactory.register(ARSKindling.device_type, ARSKindling) 
 
 

qlsdk/rsc/interface/device.py

@@ -15,6 +15,9 @@ class  IDevice(ABC):
     def device_no(self) -> str:
         pass
     
+    def produce(self, data) -> None:
+        pass
+    
     def start_listening(self):
         pass
     

qlsdk/rsc/manager/container.py

@@ -33,15 +33,15 @@ class DeviceContainer(object):
         等待设备连接
     '''
     def connect(self, device_id: str, timeout:int=30) -> Optional[IDevice]:        
-        logger.info(f"Searching for device: {device_id}")
+        logger.info(f"开始搜索设备: {device_id}")
         self.add_search(device_id)
         for s in range(timeout):
             device = self.get_device(device_id)
             if device:
-                logger.success(f"Device {device_id} connected")
+                logger.success(f"设备[{device_id}]已连接成功。")
                 return device
             time.sleep(1)
-        logger.error(f"Device {device_id} not found")
+        logger.warning(f"在{timeout}内未搜索到设备：{device_id}")
         return None
             
     def _listening(self):
@@ -55,15 +55,16 @@ class DeviceContainer(object):
 
             while True:
                 client_socket, addr = tcp_socket.accept()
-                logger.info(f"接收到来自 {addr[0]}:{addr[1]} 的连接")
+                logger.info(f"接收到来自[{addr[0]}:{addr[1]}]的连接，待确认设备类型...")
                 
                 
                 # 为每个新连接创建线程处理
                 client_handler = Thread(
                     target=self.client_handler,
-                    args=(client_socket,)
+                    args=(client_socket,),
+                    daemon=True
                 )
-                client_handler.daemon = True
+                
                 client_handler.start()
                 
         except KeyboardInterrupt:
@@ -84,18 +85,16 @@ class DeviceContainer(object):
             device.start_listening()
             # GET_DEVICE_INFO
             msg = GetDeviceInfoCommand.build(device).pack()
-            logger.info(f"发送获取设备信息命令: {msg.hex()}")
+            logger.trace(f"发送获取设备信息命令: {msg.hex()}")
             device.send(msg)
-            logger.info(f"base device {dir(device)}")
             # 添加设备
             while True:
                 if device.device_name:
-                    logger.info(f"设备 {device.device_name} 已连接")
                     real_device = DeviceFactory.create_device(device)
                     device.stop_listening()
                     real_device.start_listening()
                     self.add_device(real_device)
-                    logger.info(f"real_device consumers {len(real_device.signal_consumers)}")
+                    logger.info(f"设备[{device.device_name}]已连接，设备类型为：{hex(real_device.device_type)}")
                     break
             
         
@@ -107,20 +106,20 @@ class DeviceContainer(object):
         if device is None or device.device_no is None:
             logger.warning("无效的设备")
             
-        self._devices.update({device.device_no: device})
-        logger.debug(f"add_device {device.device_no} then has devices {self._devices}")
+        self._devices[device.device_no] = device
+        logger.info(f"添加设备[{device.device_no}]到设备列表，已连接设备数量：{len(self._devices)}")
         
-        self._broadcaster.remove_device(device.device_no)
-        logger.debug(f"add_device {device.device_no} then has broadcaster {self._broadcaster}")
+        # 标记设备为已连接
+        self._broadcaster.mark_device_as_connected(device.device_no)
         
-    def get_device(self, device_id=None)->IDevice:
-        logger.trace(f"已连接设备数量:{len(self._devices)}")
+    def get_device(self, device_no:str=None)->IDevice:
+        logger.info(f"已连接设备数量:{len(self._devices)}")
         if len(self._devices) == 0:
             return None
         
         # 未指定device_id，返回第一个设备
-        if device_id is None:
+        if device_no is None:
             return list(self._devices.values())[0]
         
-        return self._devices.get(device_id)
+        return self._devices.get(device_no, None)
             

qlsdk/rsc/network/discover.py

@@ -5,6 +5,11 @@ from loguru import logger
 
 from qlsdk.core.message import UDPMessage
 
+'''
+    广播器类，用于发送和接收设备广播消息
+    主要功能：发送设备搜索消息，接收设备连接消息
+    注意：广播端口需要和ar4sdk做区分，使用54366时不能和x8同时使用
+'''
 class UdpBroadcaster:
     # 广播端口需要和ar4sdk做区分， 使用54366时不能和x8同时使用
     def __init__(self, port=54366):
@@ -18,70 +23,54 @@ class UdpBroadcaster:
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
 
+    # 添加设备序列号到待广播列表
     def add_device(self, device_id):
-        """添加设备序列号到待广播列表"""
+        
         with self.lock:
             if device_id not in self.devices_to_broadcast:
                 self.devices_to_broadcast.append(device_id)
-                logger.info(f"Added device {device_id} to broadcast list.")
+                logger.info(f"添加设备[{device_id}]到搜索列表。")
 
+    # 从待广播列表移除设备序列号
     def remove_device(self, device_id):
-        """从待广播列表中移除设备序列号"""
+        
         with self.lock:
             if device_id in self.devices_to_broadcast:
                 self.devices_to_broadcast.remove(device_id)
-                logger.info(f"Removed device {device_id} from broadcast list.")
+                logger.info(f"把设备[{device_id}]从搜索列表中移除。")
 
+    # 把设备标记为已连接
     def mark_device_as_connected(self, device_id):
-        """将设备标记为已连接，并从未广播列表中移除"""
         with self.lock:
+            # 如果设备已连接，则从搜索列表中移除
             if device_id in self.devices_to_broadcast:
                 self.devices_to_broadcast.remove(device_id)
+                
+            # 添加到已连接设备集合
             self.connected_devices.add(device_id)
-            logger.info(f"Device {device_id} is now connected.")
+            
+            logger.info(f"设备[{device_id}]已连接，从搜索列表中移除。")
 
+    # 广播设备信息，寻求配对
     def broadcast_devices(self):
-        """轮询发送广播"""
+        
         while self.running:
             with self.lock:
                 for device_id in self.devices_to_broadcast:
                     message = UDPMessage.search(device_id)
                     self.sock.sendto(message, ('<broadcast>', self.broadcast_port))
-                    logger.info(f"Broadcasting device ID: {device_id}")
-            time.sleep(1)  # 每隔1秒发送一次广播
+                    logger.debug(f"设备[{device_id}]广播消息已发送。")
+                
+            # 每隔1秒发送一次广播    
+            time.sleep(1)  
 
     def start(self):
         """启动广播线程"""
-        self.broadcast_thread = Thread(target=self.broadcast_devices)
-        self.broadcast_thread.setDaemon(True)
+        self.broadcast_thread = Thread(target=self.broadcast_devices, daemon=True)
         self.broadcast_thread.start()
 
     def stop(self):
         """停止广播"""
         self.running = False
         self.broadcast_thread.join()
-        self.sock.close()
-
-# 示例使用
-if __name__ == "__main__":
-    broadcaster = UdpBroadcaster()
-
-    # 添加设备序列号到待广播列表
-    broadcaster.add_device_to_broadcast("390024130032")
-
-    # 启动广播
-    broadcaster.start()
-
-    try:
-        # 模拟运行一段时间
-        time.sleep(10)
-
-        # 标记设备为已连接
-        broadcaster.mark_device_as_connected("390024130032")
-
-        # 继续运行一段时间
-        time.sleep(10)
-
-    finally:
-        # 停止广播
-        broadcaster.stop()
+        self.sock.close()

qlsdk/rsc/parser/base.py

@@ -1,3 +1,6 @@
+from io import BytesIO
+from multiprocessing import Lock
+import time
 from qlsdk.rsc.interface import IDevice, IParser
 
 from loguru import logger
@@ -11,7 +14,13 @@ class TcpMessageParser(IParser):
         self.device = device    
         self.running = False
         
-        self.cache = b''
+        # 网络实时数据缓存，选用BytesIO
+        # 临时缓冲区-用于接收数据
+        self.cache = BytesIO()
+        # 缓冲区-用于处理数据
+        self.buffer = BytesIO()
+        # 读写锁-用于临时缓冲区（避免读写冲突）
+        self._lock = Lock()
         
     @property
     def header(self):
@@ -28,42 +37,114 @@ class TcpMessageParser(IParser):
     def set_device(self, device):
         self.device = device
         
-    def append(self, buffer):
-        self.cache += buffer
-        logger.trace(f"已缓存的数据长度: {len(self.cache)}")
+    def append(self, value):
+        # self.cache.write(buffer)
+        with self._lock:
+            self.cache.write(value)
         
     def __parser__(self):
-        logger.info("数据解析开始")
+        logger.trace("数据解析开始")
+        
+        # 告警阈值（10M)
+        warn_len = 10 * 1024 * 1024
+        
         while self.running:
-            if len(self.cache) < 14:
-                continue
-            if self.cache[0] != 0x5A or self.cache[1] != 0xA5:
-                self.cache = self.cache[1:]
-                continue
-            pkg_len = int.from_bytes(self.cache[8:12], 'little')
-            logger.trace(f" cache len: {len(self.cache)}, pkg_len len: {len(self.cache)}")
-            # 一次取整包数据
-            if len(self.cache) < pkg_len:
+            buf_len = get_len(self.buffer)
+            
+            # logger.info(f"当前操作区缓存长度: {buf_len}, 缓存内容: {self.buffer.getvalue().hex()}")
+            if buf_len < self.header_len:
+                # logger.trace(f"操作区缓存数据不足: {len}, 等待数据...")
+                if not self.__fill_from_cache():
+                    time.sleep(0.05)
+                    continue
+                
+            if buf_len > warn_len:
+                logger.warning(f"操作区缓存数据过大: {buf_len} bytes, 可能存在数据丢失风险")
+                
+            start_pos = self.buffer.tell()
+            # logger.info(f"当前缓存位置: {start_pos}")
+            head = self.buffer.read(2)
+            # logger.info(f'当前缓存头部: {head.hex()}')
+            if head != self.header:
+                logger.debug(f"数据包头部不匹配: {head.hex()}, 期望: {self.header.hex()},继续查找...")
+                self.buffer.seek(start_pos + 1)  # 移动到下一个字节
                 continue
-            pkg = self.cache[:pkg_len]
-            self.cache = self.cache[pkg_len:]
+            
+            # 移动下标(指向包长度的位置)
+            self.buffer.seek(start_pos + 8)
+            # 包总长度
+            pkg_len = int.from_bytes(self.buffer.read(4), 'little')
+            # logger.trace(f" cache len: {len(self.cache)}, pkg_len len: {len(self.cache)}")
+            
+            buf_len = get_len(self.buffer)
+            # 直接等待长度足够（如果从头开始判断，因为逻辑相同，所以会执行一样的操作）
+            while buf_len < pkg_len:
+                if self.__fill_from_cache():
+                    continue
+                else:
+                    time.sleep(0.05)
+                    
+            # 读取剩余数据
+            self.buffer.seek(pkg_len)
+            tmp = self.buffer.read()    
+            
+            # 读取当前数据包         
+            self.buffer.seek(start_pos)
+            pkg = self.buffer.read(pkg_len)
+            
+            # 清空操作区缓存(truncate会保留内存，重新初始化）
+            self.buffer = BytesIO()
+            if len(tmp) > 0:
+                self.buffer.write(tmp)                
+            self.buffer.seek(0)
+            
             self.unpack(pkg)
     
+    # 填充操作区缓存
+    def __fill_from_cache(self) -> bool:   
+        result = False
+        
+        cur_pos = self.buffer.tell()
+        # 移动到操作区缓存末尾，内容追加到缓冲区尾部
+        self.buffer.seek(0,2)
+        # 操作缓冲区
+        with self._lock:
+            self.cache.seek(0, 2)     
+            
+            # 临时缓冲区只要有数据，就写入操作缓冲区（避免分片传输导致数据不完整）
+            if self.cache.tell() > 0:       
+                self.buffer.write(self.cache.getvalue())
+                self.cache = BytesIO()  # 清空缓冲区
+                result = True
+            
+        self.buffer.seek(cur_pos)  # 恢复到原位置
+        
+        return result
+    
     def unpack(self, packet):        
         # 提取指令码
         cmd_code = int.from_bytes(packet[self.cmd_pos : self.cmd_pos + 2], 'little')
         cmd_class = CommandFactory.create_command(cmd_code)
-        logger.info(f"收到指令：{cmd_class.cmd_desc}[{hex(cmd_code)}]")
+        # logger.trace(f"收到指令：{cmd_class.cmd_desc}[{hex(cmd_code)}]")
         instance = cmd_class(self.device)
         start = time_ns()
-        logger.info(f"开始解析: {start}")
+        # logger.trace(f"开始解析: {start}")
         instance.parse_body(packet[self.header_len:-2])
-        logger.info(f"解析完成:{time_ns()}, 解析耗时：{time_ns() - start}ns")
+        # logger.trace(f"解析完成:{time_ns()}, 解析耗时：{time_ns() - start}ns")
         return instance
             
     def start(self):
         self.running = True
-        parser = Thread(target=self.__parser__,)
-        parser.daemon = True
+        parser = Thread(target=self.__parser__, daemon=True)
         parser.start()
-        
+        
+# 工具方法
+def get_len(buf: BytesIO) -> int:
+        if buf is None:
+            return 0
+        cur_pos = buf.tell()
+        buf.seek(0, 2)  # 移动到操作区缓存末尾
+        len = buf.tell()
+        buf.seek(cur_pos)  # 恢复到原位置
+        return len
+    

qlsdk2-0.5.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.2
+Name: qlsdk2
+Version: 0.5.0
+Summary: SDK for quanlan device
+Home-page: https://github.com/hehuajun/qlsdk
+Author: hehuajun
+Author-email: hehuajun@eegion.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: loguru>=0.6.0
+Requires-Dist: numpy>=1.23.5
+Requires-Dist: bitarray>=1.5.3
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: twine>=3.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+版本：v0.5.0 
+时间：2025-07-29
+[新特性]
+1. C16R设备搜索
+2、C16R设备连接
+3、C16R信号采集/停止
+4、C16R数据自动记录到文件
+5、C16R采集通道设置支持数字和名称两种模式（可混用）
+
+[优化]
+1、提升信号接收及指令解析性能
+2、日志级别及文案优化

{qlsdk2-0.4.2.dist-info → qlsdk2-0.5.0.dist-info}/RECORD

@@ -20,7 +20,7 @@ qlsdk/core/network/monitor.py,sha256=QqjjPwSr1kgqDTTySp5bpalZmsBQTaAWSxrfPLdROZo
 qlsdk/persist/__init__.py,sha256=b8qk1aOU6snEMCQNYDl1ijV3-2gwBmMt76fiAzNk1E8,107
 qlsdk/persist/ars_edf.py,sha256=_pYtHqucB-utMw-xUXZc9IB8_8ThbLFpTl_-WBQR-Sc,10555
 qlsdk/persist/edf.py,sha256=ETngb86CfkIUJYWmw86QR445MvTFC7Edk_CH9nyNgtY,7857
-qlsdk/persist/rsc_edf.py,sha256=fY1eRMflCvOshN_YTxmzT3MYzEHyHtNMiczCgXWgJ7w,11878
+qlsdk/persist/rsc_edf.py,sha256=wV3akdwzEihDAyR9DtmO0jNdLH1jEvx34ghJQtrfk2k,12578
 qlsdk/persist/stream.py,sha256=TCVF1sqDrHiYBsJC27At66AaCs-_blXeXA_WXdJiIVA,5828
 qlsdk/rsc/__init__.py,sha256=hOMiN0eYn4jYo7O4_0IPlQT0hD15SqqCQUihOVlTZvs,269
 qlsdk/rsc/device_manager.py,sha256=1ucd-lzHkNeQPKPzXV6OBkAMqPp_vOcsLyS-9TJ7wRc,4448
@@ -29,27 +29,28 @@ qlsdk/rsc/eegion.py,sha256=lxrktO-3Z_MYdFIwc4NxvgLM5AL5kU3UItjH6tsKmHY,11670
 qlsdk/rsc/entity.py,sha256=-fRWFkVWp9d8Y1uh6GiacXC5scdeEKNiNFf3aziGdCE,17751
 qlsdk/rsc/paradigm.py,sha256=DGfwY36sMdPIMRjbGo661GvUTEwsRRi3jrmG405mSTk,12840
 qlsdk/rsc/proxy.py,sha256=9CPdGNGWremwBUh4GvlXAykYB-x_BEPPLqsNvwuwIDE,2736
-qlsdk/rsc/command/__init__.py,sha256=3rONCv9eFjIS1Hk2T0uoCwSo_wt89QSi1PYfdFNLv3k,11896
+qlsdk/rsc/command/__init__.py,sha256=FpumdCRV3aSnCvLT7MceMb7lF8WgGbdi_w0L8wX7ryg,12137
 qlsdk/rsc/command/message.py,sha256=nTdG-Vp4MBnltyrgedAWiKD6kzOaPrg58Z_hq6yjhys,12220
-qlsdk/rsc/device/__init__.py,sha256=5tNSYmpl_jfaHZcOMyB2IcO-tzL-Pj5f3V8CRC8uLHc,73
-qlsdk/rsc/device/arskindling.py,sha256=HEy0yCloDWiveRT5lY3qVDAfqPfr_FiztbiZeqQPT3k,14895
-qlsdk/rsc/device/base.py,sha256=lrdLi9OXeVgLsUn5Bif9sJ9PZo5cDUQ-moOGur5Gsp8,15685
-qlsdk/rsc/device/c256_rs.py,sha256=ns4osmACbStDf7oz8aBnfZhJCe1R2g3M--_Oum6eN50,13921
-qlsdk/rsc/device/c64_rs.py,sha256=hzOQxtZf_X-sdTR32-WsO7MNGn-tyPImuXRpwpdSMTo,13578
-qlsdk/rsc/device/c64s1.py,sha256=2TmJJ9Ncr0jy8HtdI66C-kSFyCSqAILco3Eijth_oIo,13920
-qlsdk/rsc/device/device_factory.py,sha256=B_JZOAGGaLafSdly2i6PeIV2rVoz7S3MJyFfUCICu94,1257
+qlsdk/rsc/device/__init__.py,sha256=xtTXLT9QFKtb-qS-A8-ewSxJ3zXgImFCX0OoAPw6hHE,185
+qlsdk/rsc/device/arskindling.py,sha256=owci6MEGjyWqohEXzPdKj_ESeVIZKgO53StVj6Tmi18,15002
+qlsdk/rsc/device/base.py,sha256=6cMaACVVgZ7oKdqbyVRl3B32M9Em6_jjr-FUuxRW6Ys,17404
+qlsdk/rsc/device/c16_rs.py,sha256=IpJn4hBFHg67lvWkl8kAAztdZYsgi2-njFuxMi2SsHQ,6390
+qlsdk/rsc/device/c256_rs.py,sha256=K1XmLqZpvHTAfCm_dr2VsGxHc67aJQVDV1cI41a1WTI,13955
+qlsdk/rsc/device/c64_rs.py,sha256=cZIioIRGgd4Ub0ieho4_XujBNo8AQgJEjXcqgcEkyFQ,13644
+qlsdk/rsc/device/c64s1.py,sha256=L7nKmsoMCGj6GMjHYfYkKgkBtrGfP516kQHQ5I1FAUE,13986
+qlsdk/rsc/device/device_factory.py,sha256=P8nNDB2qk0kbu4OMYtEZMKSdXWp-7fLDzuNyR1Thf8Q,1315
 qlsdk/rsc/interface/__init__.py,sha256=xeRzIlQSB7ZSf4r5kLfH5cDQLzCyWeJAReG8Xq5nOE0,70
 qlsdk/rsc/interface/command.py,sha256=1s5Lxb_ejsd-JNvKMqU2aFSnOoW-_cx01VSD3czxmQI,199
-qlsdk/rsc/interface/device.py,sha256=0wCKyI19fbDHVuIMoOhLcJTUSbp4D8ou9SfBVxYA8Qs,3034
+qlsdk/rsc/interface/device.py,sha256=apBQAeu1g0Qmw73qQqr6uG1re9qCep6oKfjWKlGJdp4,3092
 qlsdk/rsc/interface/handler.py,sha256=ADDe_a2RAxGMuooLyivH0JBPTGBcFP2JaTVX41R1A4w,198
 qlsdk/rsc/interface/parser.py,sha256=DxuFZiprJJbG4pfFbbZPaG8MlBiBRe0S0lJrvc2Iees,251
 qlsdk/rsc/manager/__init__.py,sha256=4ljT3mR8YPBDQur46B5xPqK5tjLKlsWfgCJVuA0gs-8,40
-qlsdk/rsc/manager/container.py,sha256=4yQH8P_pEk7vaO_UYkEe9UPga7pFdcKgo1ZpOApAFqM,4866
+qlsdk/rsc/manager/container.py,sha256=N9QB85FOA_7Oa_8M1y1M2UODA_tpS9JQONhGj8ObBG8,4811
 qlsdk/rsc/manager/search.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qlsdk/rsc/network/__init__.py,sha256=PfYiqXS2pZV__uegQ1TjaeYhY1pefZ_shwE_X5HNVbs,23
-qlsdk/rsc/network/discover.py,sha256=ONXN6YWY-OMU0sBoLqqKUyb-8drtAp1g_MvnpzaFvHQ,3124
+qlsdk/rsc/network/discover.py,sha256=4aojzRFInTC3d8K2TYGbnP1Ji5fOFEi31ekghj7ce5k,2977
 qlsdk/rsc/parser/__init__.py,sha256=8RgwbKCINu3eTsxVLF9cMoBXJnVrDocOEFP6NGP_atk,34
-qlsdk/rsc/parser/base.py,sha256=mR41XedSptTwbMdo-KZ_ejo2b2pi5pc-_TGWfW2AF34,2277
+qlsdk/rsc/parser/base.py,sha256=s6tkWQXoMq8ZA4Nns_aG1JS5PV3UXLMFarTZiCoPagM,5504
 qlsdk/sdk/__init__.py,sha256=v9LKP-5qXCqnAsCkiRE9LDb5Tagvl_Qd_fqrw7y9yd4,68
 qlsdk/sdk/ar4sdk.py,sha256=tugH3UUeNebdka78AzLyrtAXbYQQE3iFJ227zUit6tY,27261
 qlsdk/sdk/hub.py,sha256=uEOGZBZtMDCWlV8G2TZe6FAo6eTPcwHAW8zdqr1eq_0,1571
@@ -57,7 +58,7 @@ qlsdk/sdk/libs/libAr4SDK.dll,sha256=kZp9_DRwPdAJ5OgTFQSqS8tEETxUs7YmmETuBP2g60U,
 qlsdk/sdk/libs/libwinpthread-1.dll,sha256=W77ySaDQDi0yxpnQu-ifcU6-uHKzmQpcvsyx2J9j5eg,52224
 qlsdk/x8/__init__.py,sha256=FDpDK7GAYL-g3vzfU9U_V03QzoYoxH9YLm93PjMlANg,4870
 qlsdk/x8m/__init__.py,sha256=cLeUqEEj65qXw4Qa4REyxoLh6T24anSqPaKe9_lR340,634
-qlsdk2-0.4.2.dist-info/METADATA,sha256=g6FdFdj4E8B5kRk-MVTVnaUli_S0Z6ckyNKTADf6Dd4,7063
-qlsdk2-0.4.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-qlsdk2-0.4.2.dist-info/top_level.txt,sha256=2CHzn0SY-NIBVyBl07Suh-Eo8oBAQfyNPtqQ_aDatBg,6
-qlsdk2-0.4.2.dist-info/RECORD,,
+qlsdk2-0.5.0.dist-info/METADATA,sha256=Lp7nByzF1dCM1LGXQxyKv8sc-vkTDuLjZtw9nu_JFBk,1134
+qlsdk2-0.5.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+qlsdk2-0.5.0.dist-info/top_level.txt,sha256=2CHzn0SY-NIBVyBl07Suh-Eo8oBAQfyNPtqQ_aDatBg,6
+qlsdk2-0.5.0.dist-info/RECORD,,

qlsdk2-0.4.2.dist-info/METADATA

@@ -1,121 +0,0 @@
-Metadata-Version: 2.2
-Name: qlsdk2
-Version: 0.4.2
-Summary: SDK for quanlan device
-Home-page: https://github.com/hehuajun/qlsdk
-Author: hehuajun
-Author-email: hehuajun@eegion.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: loguru>=0.6.0
-Requires-Dist: numpy>=1.23.5
-Requires-Dist: bitarray>=1.5.3
-Provides-Extra: dev
-Requires-Dist: pytest>=6.0; extra == "dev"
-Requires-Dist: twine>=3.0; extra == "dev"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# qlsdk project
-
-
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin http://10.60.170.104/sw/qlsdk-project.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](http://10.60.170.104/sw/qlsdk-project/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.