qlsdk2 0.4.2__tar.gz → 0.5.0__tar.gz

qlsdk2-0.5.0/PKG-INFO

@@ -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.5.0/README.md

@@ -0,0 +1,12 @@
+版本：v0.5.0 
+时间：2025-07-29
+[新特性]
+1. C16R设备搜索
+2、C16R设备连接
+3、C16R信号采集/停止
+4、C16R数据自动记录到文件
+5、C16R采集通道设置支持数字和名称两种模式（可混用）
+
+[优化]
+1、提升信号接收及指令解析性能
+2、日志级别及文案优化

{qlsdk2-0.4.2 → qlsdk2-0.5.0}/setup.py

@@ -1,12 +1,12 @@
 # setup.py
 import setuptools
 
-with open("README.md", "r") as fh:
+with open("README.md", "r", encoding='utf-8' ) as fh:
     long_description = fh.read()
 
 setuptools.setup(
     name="qlsdk2",
-    version="0.4.2",
+    version="0.5.0",
     author="hehuajun",
     author_email="hehuajun@eegion.com",
     description="SDK for quanlan device",

{qlsdk2-0.4.2 → qlsdk2-0.5.0}/src/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

{qlsdk2-0.4.2 → qlsdk2-0.5.0}/src/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)
                 
             
 

qlsdk2-0.5.0/src/qlsdk/rsc/device/__init__.py

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

{qlsdk2-0.4.2 → qlsdk2-0.5.0}/src/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

{qlsdk2-0.4.2 → qlsdk2-0.5.0}/src/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: