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

qlsdk/core/entity/__init__.py

@@ -1,18 +1,17 @@
 from qlsdk.core.utils import to_channels
 from loguru import logger
 
-class DataPacket(object):
-    def __init__(self, device_type, device_id, channels, data):
-        self.data = data
-        self.channels = None
-        
-            
-class RscPacket(object):
+class Packet(object):
     def __init__(self):
         self.time_stamp = None
         self.pkg_id = None
         self.result = None
         self.channels = None
+        
+            
+class RscPacket(Packet):
+    def __init__(self):
+        super().__init__()
         self.origin_sample_rate = None
         self.sample_rate = None
         self.sample_num = None
@@ -65,12 +64,9 @@ class RscPacket(object):
             eeg: {self.eeg}
         """
         
-class ImpedancePacket(object):
+class ImpedancePacket(Packet):
     def __init__(self):
-        self.time_stamp = None
-        self.pkg_id = None
-        self.result = None
-        self.channels = None
+        super().__init__()
         self.data_len = None
         self.impedance = None
         

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
@@ -14,7 +15,8 @@ EDF_FILE_TYPE = {
 }
 
 class EDFStreamWriter(Thread):
-    def __init__(self, channels, sample_frequency, physical_max, digital_min, file_type, file_path):
+    def __init__(self, channels, sample_frequency, physical_max, digital_min, file_type, file_path, record_duration=None):
+        
         super().__init__()
         self._writer : EdfWriter = None
         self.data_queue : Queue = Queue()
@@ -22,6 +24,8 @@ class EDFStreamWriter(Thread):
         self._points = 0
         self._duration = 0
         self._buffer = None
+        # 设置edf/bdf文件参数，设置[0.001, 1)可以在1秒内记录多个事件（不建议开启）
+        self.record_duration = record_duration
         
         # signal info
         self._channels = channels
@@ -61,9 +65,10 @@ class EDFStreamWriter(Thread):
             # 数据
             self.data_queue.put(data)
             
-    def trigger(self, onset, desc):
+    def trigger(self, onset, desc: str):
         if self._writer:            
-            self._writer.writeAnnotation(onset, 1, desc)
+            logger.trace(f"[{onset} : {desc}]")
+            self._writer.writeAnnotation(onset, -1, desc)
         else:
             logger.warning("未创建文件，无法写入Trigger标记")
         
@@ -77,8 +82,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 +94,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):
@@ -126,6 +139,8 @@ class EDFStreamWriter(Thread):
             })
         
         self._writer.setSignalHeaders(signal_headers)
+        if self.record_duration:
+            self._writer.setDatarecordDuration(self.record_duration)  # 每个数据块1秒
         
     def _write_file(self, eeg_data):
         try:            
@@ -159,6 +174,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的全部前置参数
@@ -177,7 +195,7 @@ class RscEDFHandler(object):
         @author: qlsdk
         @since: 0.4.0
     '''
-    def __init__(self, eeg_sample_rate, physical_max, physical_min, resolution=24, storage_path = None):
+    def __init__(self, eeg_sample_rate, physical_max, physical_min, resolution=24, storage_path = None, record_duration=None):
         # edf文件参数
         self.physical_max = physical_max
         self.physical_min = physical_min
@@ -213,6 +231,7 @@ class RscEDFHandler(object):
         self._total_packets = 0
         self._lost_packets = 0
         self._storage_path = storage_path
+        self._record_duration = record_duration
         self._edf_writer_thread = None
         self._file_prefix = None
         
@@ -243,6 +262,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 +285,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
@@ -284,7 +306,7 @@ class RscEDFHandler(object):
             self._total_packets += 1
             
             if self._edf_writer_thread is None:
-                self._edf_writer_thread = EDFStreamWriter(self.channels, self.sample_rate, self.physical_max, self.physical_min, self.file_type, self.file_name)
+                self._edf_writer_thread = EDFStreamWriter(self.channels, self.sample_rate, self.physical_max, self.physical_min, self.file_type, self.file_name, self._record_duration)
                 self._edf_writer_thread.set_start_time(self._start_time)
                 self._edf_writer_thread.start()
                 logger.info(f"开始写入数据: {self.file_name}")
@@ -295,9 +317,16 @@ class RscEDFHandler(object):
     # trigger标记
     # desc: 标记内容
     # cur_time: 设备时间时间戳，非设备发出的trigger不要设置
-    def trigger(self, desc, cur_time=None):
+    def trigger(self, desc: str, cur_time=None):
+        if self._edf_writer_thread is None:
+            logger.warning(f"File writing has not started, discarding trigger {desc}")
+            return
+        
         if cur_time is None:
-            onset = datetime.now().timestamp() - self._start_time.timestamp()
+            # 计算trigger位置
+            if self._start_time:
+                onset = datetime.now().timestamp() - self._start_time.timestamp()
+            else: onset = 0
         else:
             onset = cur_time - self._first_timestamp
         self._edf_writer_thread.trigger(onset, desc)     

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 '失败'}")
         
     
 
@@ -156,7 +170,7 @@ class QueryBatteryCommand(DeviceCommand):
             self.device.battery_total = body[12]
             # state - 1b
             # state = body[13]
-            logger.debug(f"电量更新: {self.device}")
+            logger.trace(f"电量更新: {self.device}")
         else:
             logger.warning(f"QueryBatteryCommand message received but result is failed.")
 
@@ -200,6 +214,10 @@ class StartImpedanceCommand(DeviceCommand):
         body += to_bytes(self.device.acq_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) 
         
 
 # 停止阻抗测量
@@ -279,7 +297,7 @@ class ImpedanceDataCommand(DeviceCommand):
     cmd_desc = "阻抗数据"
     
     def parse_body(self, body: bytes):
-        logger.info(f"Received impedance data: {body.hex()}")
+        # logger.info(f"Received impedance data: {body.hex()}")
         packet = ImpedancePacket().transfer(body)
 
 # 信号数据
@@ -294,18 +312,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):
@@ -19,6 +20,9 @@ class QLBaseDevice(IDevice):
         # 启动数据解析线程
         self._parser: IParser = None
         
+        # 用在edf/bdf文件写入中，不建议使用
+        self._record_duration = None    
+        
         # 设备信息
         self.device_id = None
         self.device_name = None
@@ -117,8 +121,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 +132,45 @@ class QLBaseDevice(IDevice):
         
     def parser(self) -> IParser:
         return self._parser
+    
+    def set_record_duration(self, record_duration: float):
+        self._record_duration = record_duration      
+    
+    # 数据包处理
+    def produce(self, data: RscPacket, type:Literal['signal', 'impedance']="signal"):
+        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()):
+                # 队列满了就丢弃最早的数据
+                if q.full(): 
+                    q.get()
+                    
+                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,8 +185,9 @@ class QLBaseDevice(IDevice):
         return True
     
     def stop_listening(self):
-        logger.info(f"设备{self.device_no}停止socket监听")
-        self._listening = False
+        logger.trace(f"设备{self.device_no}停止socket监听")
+        self._listening = False        
+        self._parser.stop()
         
     @property
     def device_type(self) -> int:
@@ -152,15 +196,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 +213,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 +250,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 +266,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 +293,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 +329,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 +356,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 +431,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: