qlsdk2 0.4.0a3__tar.gz → 0.4.1__tar.gz

{qlsdk2-0.4.0a3 → qlsdk2-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qlsdk2
-Version: 0.4.0a3
+Version: 0.4.1
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun

{qlsdk2-0.4.0a3 → qlsdk2-0.4.1}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="qlsdk2",
-    version="0.4.0a3",
+    version="0.4.1",
     author="hehuajun",
     author_email="hehuajun@eegion.com",
     description="SDK for quanlan device",

{qlsdk2-0.4.0a3 → qlsdk2-0.4.1}/src/qlsdk/ar4/__init__.py

@@ -39,12 +39,12 @@ class AR4(LMDevice):
                 consumer.put(packet)
              
             if len(self._phy_subscriber) > 0:
-                logger.info(f"dig data eeg: {packet.eeg}")
-                logger.info(f"dig data acc: {packet.acc}")
+                logger.debug(f"dig data eeg: {packet.eeg}")
+                logger.debug(f"dig data acc: {packet.acc}")
                 packet.eeg = self.eeg2phy(np.array(packet.eeg))
                 packet.acc = self.acc2phy(np.array(packet.acc))
-                logger.info(f"phy data eeg: {packet.eeg}")
-                logger.info(f"phy data acc: {packet.acc}")
+                logger.debug(f"phy data eeg: {packet.eeg}")
+                logger.debug(f"phy data acc: {packet.acc}")
                 for consumer2 in self._phy_subscriber.values():
                     consumer2.put(packet)
             
@@ -74,7 +74,11 @@ class AR4(LMDevice):
             self._edf_handler = None
             self._recording = False
             logger.info(f"停止记录数据: {self.box_mac}")
-
+            
+    def trigger(self, desc):
+        if self._edf_handler:
+            self._edf_handler.trigger(desc)
+            
     # 订阅推送消息 
     def subscribe(self, topic: str = None, q: Queue = Queue(), value_type: Literal['phy', 'dig'] = 'phy') -> tuple[str, Queue]:
         if topic is None:

{qlsdk2-0.4.0a3 → qlsdk2-0.4.1}/src/qlsdk/core/device.py

@@ -4,9 +4,18 @@ class BaseDevice(object):
     def __init__(self, socket = None):
         self.socket = socket
         self.device_name = None
-        self.device_type = None
+        self._device_type = None
         self.device_id = None
         
+        
+    @property
+    def device_type(self) -> int:
+        return self._device_type
+    
+    @device_type.setter
+    def device_type(self, value: int):
+        self._device_type = value
+        
     @property
     def acq_channels(self) :
         return None

{qlsdk2-0.4.0a3 → qlsdk2-0.4.1}/src/qlsdk/core/message/command.py

@@ -1,8 +1,10 @@
 import abc
+import numpy as np
 from time import time_ns
 from typing import Dict, Type
-from enum import Enum
 from loguru import logger
+
+
 from qlsdk.core.crc import crc16
 from qlsdk.core.device import BaseDevice
 from qlsdk.core.entity import RscPacket, ImpedancePacket
@@ -64,6 +66,13 @@ class DeviceCommand(abc.ABC):
         # 解析消息体
         body = payload[self.HEADER_LEN:-2]   
     
+    def parse_body(self, body: bytes):
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        logger.info(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
+        
+    
 
 class CommandFactory:
     """Registry for command implementations"""
@@ -114,6 +123,8 @@ class GetDeviceInfoCommand(DeviceCommand):
         flag = int.from_bytes(body[41:45], 'little')
         logger.debug(f"Received device info: {result}, {flag}, {self.device}")
         
+        # 创建设备对象
+        
 
 # 握手
 class HandshakeCommand(DeviceCommand):
@@ -160,8 +171,6 @@ class SetAcquisitionParamCommand(DeviceCommand):
         body += bytes.fromhex('00')        
 
         return body
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetAcquisitionParam response: {body.hex()}")
         
 # 启动采集
 class StartAcquisitionCommand(DeviceCommand):
@@ -170,8 +179,6 @@ class StartAcquisitionCommand(DeviceCommand):
     
     def pack_body(self):
         return bytes.fromhex('0000')
-    def parse_body(self, body: bytes):
-        logger.info(f"Received acquisition start response: {body.hex()}")
 
 # 停止采集
 class StopAcquisitionCommand(DeviceCommand):
@@ -180,17 +187,14 @@ class StopAcquisitionCommand(DeviceCommand):
     
     def pack_body(self):
         return b''
-    def parse_body(self, body: bytes):
-        logger.info(f"Received acquisition stop response: {body.hex()}")
+
         
 # 设置阻抗采集参数
 class SetImpedanceParamCommand(DeviceCommand):
     cmd_code = 0x411
     cmd_desc = "设置阻抗测量参数"
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetImpedanceParamCommand response: {body.hex()}")
         
-# 启动采集
+# 启动阻抗测量
 class StartImpedanceCommand(DeviceCommand):
     cmd_code = 0x412
     cmd_desc = "启动阻抗测量"
@@ -200,19 +204,14 @@ class StartImpedanceCommand(DeviceCommand):
         body += bytes.fromhex('0000000000000000') # 8字节占位符
         return body
         
-    def parse_body(self, body: bytes):
-        logger.info(f"Received StartImpedanceCommand response: {body.hex()}")
 
-# 停止采集
+# 停止阻抗测量
 class StopImpedanceCommand(DeviceCommand):
     cmd_code = 0x413
     cmd_desc = "停止阻抗测量"
     
     def pack_body(self):
         return b''
-
-    def parse_body(self, body: bytes):
-        logger.info(f"Received StopImpedanceCommand response: {body.hex()}")
             
 # 启动刺激
 class StartStimulationCommand(DeviceCommand):
@@ -229,19 +228,36 @@ class StartStimulationCommand(DeviceCommand):
         # error_channel - 8B
         # error_channel= int.from_bytes(body[9:17], 'big')
         channels = to_channels(body[9:17])
-        logger.warning(f"通道 {channels} 刺激开始")
+        logger.success(f"通道 {channels} 刺激开始")
+        self.device.trigger(f"通道 {channels} 刺激开始")
         # error_type - 1B
         error_type = body[17]
 
-# 停止采集
+# 停止刺激
 class StopStimulationCommand(DeviceCommand):
     cmd_code = 0x488
     cmd_desc = "停止刺激"
-    
+     
+# 启动刺激
+class StopStimulationNotifyCommand(DeviceCommand):
+    cmd_code = 0x48D
+    cmd_desc = "停止刺激通知"
+    def pack_body(self):
+        return self.device.stim_paradigm.to_bytes()
+        # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
     def parse_body(self, body: bytes):
-        logger.info(f"Received stimulation stop response: {body.hex()}")
-        
-# 停止采集
+        # time - 8B
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        # error_channel - 8B
+        # error_channel= int.from_bytes(body[9:17], 'big')
+        channels = to_channels(body[9:17])
+        logger.success(f"通道 {channels} 刺激结束")
+        self.device.trigger(f"通道 {channels} 刺激结束", time)
+        # error_type - 1B
+        error_type = body[17]   
+# 刺激信息
 class StimulationInfoCommand(DeviceCommand):
     cmd_code = 0x48e
     cmd_desc = "刺激告警信息"
@@ -254,9 +270,10 @@ class StimulationInfoCommand(DeviceCommand):
         channels = to_channels(body[9:17])
         # 保留位-8B
         # error_type - 1B
+        err_type = body[17]
         # 特征位-4B
-        characteristic  = int.from_bytes(body[25:29], 'little')
-        logger.warning(f"[{characteristic}]刺激告警，通道 {channels} 刺激驱动不足")
+        # errType  = int.from_bytes(body[25:29], 'little')
+        logger.warning(f"刺激告警信息[{err_type}]，通道 {channels} 刺激驱动不足")
         
 
 # 阻抗数据
@@ -276,24 +293,28 @@ class SignalDataCommand(DeviceCommand):
     def unpack(self, payload):
         return super().unpack(payload)
     
-    def parse_body(self, body: bytes):                
-        if len(self.device.signal_consumers) > 0 or self.device.edf_handler:
-            # 解析数据包
-            rsc = RscPacket()
-            rsc.transfer(body)
+    def parse_body(self, body: bytes):     
+        # 解析数据包
+        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(rsc)
+                q.put(packet)
                 
-            # 文件写入到edf
-            if self.device.edf_handler:
-                self.device.edf_handler.append(rsc)
+            
 
 # =============================================================================
-# Command Registration
+# 指令实现类注册到指令工厂
 # =============================================================================
-
 CommandFactory.register_command(DefaultCommand.cmd_code, DefaultCommand)
 CommandFactory.register_command(GetDeviceInfoCommand.cmd_code, GetDeviceInfoCommand)
 CommandFactory.register_command(HandshakeCommand.cmd_code, HandshakeCommand)

{qlsdk2-0.4.0a3 → qlsdk2-0.4.1}/src/qlsdk/persist/edf.py

@@ -34,6 +34,7 @@ class EdfHandler(object):
         self._first_pkg_id = None
         self._last_pkg_id = None
         self._first_timestamp = None
+        self._first_time = None
         self._end_time = None
         self._patient_code = "patient_code"
         self._patient_name = "patient_name"
@@ -77,6 +78,7 @@ class EdfHandler(object):
                 self.acc_channels = data.acc_ch_count
                 self._first_pkg_id = data.pkg_id
                 self._first_timestamp = data.time_stamp
+                self._first_time = datetime.now()
                 
             if self._last_pkg_id and self._last_pkg_id != data.pkg_id - 1:  
                 self._lost_packets += data.pkg_id - self._last_pkg_id - 1
@@ -90,8 +92,25 @@ class EdfHandler(object):
         if not self._recording:
             self.start()
     
-    def trigger(self, data):
-        pass        
+    # trigger标记
+    # desc: 标记内容
+    # cur_time: 设备时间时间戳，非设备发出的trigger不要设置
+    def trigger(self, desc, cur_time=None):
+        if self._edf_writer is None:
+            logger.warning("EDF writer未初始化，无法写入trigger标记")
+            return
+        
+        if cur_time is None:
+            onset = datetime.now().timestamp() - self._first_time.timestamp()
+        else:
+            onset = cur_time - self._first_timestamp
+            
+        self._edf_writer.writeAnnotation(onset, 1, desc)
+    
+    
+    # def trigger(self, desc):
+    #     if self._edf_writer:            
+    #         self._edf_writer.writeAnnotation(0, 1, desc)
     
     def start(self):
         self._recording = True

qlsdk2-0.4.1/src/qlsdk/persist/rsc_edf.py

@@ -0,0 +1,300 @@
+from datetime import datetime
+from multiprocessing import Lock, Queue
+from time import time_ns
+from pyedflib import FILETYPE_BDFPLUS, FILETYPE_EDFPLUS, EdfWriter
+from threading import Thread
+from loguru import logger
+import numpy as np
+import os
+from qlsdk.core import RscPacket
+
+EDF_FILE_TYPE = {
+    "bdf": FILETYPE_BDFPLUS,
+    "edf": FILETYPE_EDFPLUS
+}
+
+class EDFStreamWriter(Thread):
+    def __init__(self, channels, sample_frequency, physical_max, digital_min, file_type, file_path):
+        super().__init__()
+        self._writer : EdfWriter = None
+        self.data_queue : Queue = Queue()
+        self._recording = False
+        self._points = 0
+        self._duration = 0
+        self._buffer = None
+        
+        # signal info
+        self._channels = channels
+        self._n_channels = len(channels)
+        self.sample_frequency = sample_frequency
+        self.physical_max = physical_max
+        self.physical_min = digital_min
+        # 和位数相关，edf 16 bits/bdf  24 bits
+        self.digital_max = 8388607 if file_type == EDF_FILE_TYPE['bdf'] else 32767
+        self.digital_min = -8388608 if file_type == EDF_FILE_TYPE['bdf'] else -32768
+        self.file_type = file_type
+        self.file_path = file_path
+        
+        # 记录开始时间
+        self.start_time = None
+        
+        # header info
+        self.equipment = "equipment"
+        self.patient_code = "patient_code"
+        self.patient_name = "patient_name"
+        
+    def set_channels(self, channels):
+        self._channels = channels
+        self._n_channels = len(channels)
+        
+    def set_sample_rate(self, sample_rate):
+        self._sample_rate = sample_rate
+        
+    def set_start_time(self, time):
+        self.start_time = time
+
+    def stop_recording(self):
+        self._recording = False
+        
+    def append(self, data):
+        if data:
+            # 数据
+            self.data_queue.put(data)
+            
+    def trigger(self, onset, desc):
+        if self._writer:            
+            self._writer.writeAnnotation(onset, 1, desc)
+        else:
+            logger.warning("未创建文件，无法写入Trigger标记")
+        
+        
+    def run(self):
+        logger.debug(f"启动bdf文件写入线程，写入数据到文件 {self.file_path}")
+        # 记录状态
+        self._recording = True
+        
+        #  初始化
+        if self._writer is None:
+            self._init_writer()
+            
+        while True:
+            if self._recording or (not self.data_queue.empty()):
+                try:
+                    data = self.data_queue.get(timeout=30)
+                    if data is None:
+                        logger.debug("收到结束信号，停止写入数据")
+                        break
+                    # 处理数据
+                    self._points += len(data[1])
+                    logger.trace(f"已处理数据点数：{self._points}")
+                    self._write_file(data)
+                except Exception as e:
+                    logger.error(f"异常或超时(30s)结束: {str(e)}")
+                    break
+            else:
+                logger.debug("数据记录完成")
+                break
+            
+        self.close()
+        
+    def _init_writer(self):
+        
+        # 创建EDF+写入器
+        self._writer = EdfWriter(
+            self.file_path,
+            self._n_channels,
+            file_type=self.file_type
+        )
+        
+        # 设置头信息
+        self._writer.setPatientCode(self.patient_code)
+        self._writer.setPatientName(self.patient_name)
+        self._writer.setEquipment(self.equipment)
+        self._writer.setStartdatetime(self.start_time if self.start_time else datetime.now())
+        
+        # 配置通道参数
+        signal_headers = []
+        for ch in range(self._n_channels):
+            signal_headers.append({
+                "label": f'channels {self._channels[ch]}',
+                "dimension": 'uV',
+                "sample_frequency": self.sample_frequency,
+                "physical_min": self.physical_min,
+                "physical_max": self.physical_max,
+                "digital_min": self.digital_min,
+                "digital_max": self.digital_max
+            })
+        
+        self._writer.setSignalHeaders(signal_headers)
+        
+    def _write_file(self, eeg_data):
+        try:            
+            if self._buffer is None or self._buffer.size == 0:
+                self._buffer = np.asarray(eeg_data)
+            else:                
+                self._buffer = np.hstack((self._buffer, eeg_data))
+            
+            if self._buffer.shape[1] >= self.sample_frequency:      
+                block = self._buffer[:, :self.sample_frequency]          
+                self._write_block(block)
+                self._buffer = self._buffer[:, self.sample_frequency:]      
+            
+        except Exception as e:
+            logger.error(f"写入数据异常: {str(e)}")
+        
+    def close(self):
+        self._recording = False
+        if self._writer:            
+            self._writer.writeAnnotation(0, 1, "recording start")
+            self._writer.writeAnnotation(self._duration, 1, "recording end")
+            self._writer.close()
+        
+        logger.info(f"文件: {self.file_path}完成记录, 总点数: {self._points}, 总时长: {self._duration}秒")
+    
+    # 写入1秒的数据
+    def _write_block(self, block):
+        logger.trace(f"写入数据: {block}")
+        # 转换数据类型为float64
+        data_float64 = block.astype(np.float64)
+        # 写入时转置为(样本数, 通道数)格式
+        self._writer.writeSamples(data_float64)
+        self._duration += 1
+
+# 用作数据结构一致化处理，通过调用公共类写入edf文件
+# 入参包含写入edf的全部前置参数
+# 实时数据包为个性化数据包，含有eeg数据部分
+class RscEDFHandler(object):
+    '''
+        Rsc EDF Handler
+        处理EDF文件的读写
+        RSC设备通道数根据选择变化，不同通道采样频率相同
+        eeg_sample_rate: 采样频率
+        physical_max: 物理最大值 (uV)   
+        physical_min: 物理最小值 (uV)
+        resolution: 分辨率
+        storage_path: 存储路径        
+        
+        @author: qlsdk
+        @since: 0.4.0
+    '''
+    def __init__(self, eeg_sample_rate, physical_max, physical_min, resolution=24, storage_path = None):
+        # edf文件参数
+        self.physical_max = physical_max
+        self.physical_min = physical_min
+        self.digital_max = 8388607 if resolution == 24 else 32767
+        self.digital_min = -8388607 if resolution == 24 else - 32768
+        self.file_type = EDF_FILE_TYPE["bdf"] if resolution == 24 else EDF_FILE_TYPE["edf"]
+        # 点分辨率
+        self.resolution = resolution
+        # eeg通道数
+        self.channels = None
+        # eeg采样率
+        self.sample_rate = eeg_sample_rate
+        # bytes per second
+        self.bytes_per_second = 0
+        self._edf_writer = None
+        self._cache2 = tuple()
+        self._recording = False
+        self._edf_writer = None
+        self.annotations = None
+        # 每个数据块大小
+        self._chunk = np.array([])
+        self._Lock = Lock()
+        self._duration = 0
+        self._points = 0
+        self._first_pkg_id = None
+        self._last_pkg_id = None
+        self._first_timestamp = None
+        self._start_time = None
+        self._end_time = None
+        self._patient_code = "patient_code"
+        self._patient_name = "patient_name"
+        self._device_type = "24130032"
+        self._device_no = "24130032"
+        self._total_packets = 0
+        self._lost_packets = 0
+        self._storage_path = storage_path
+        self._edf_writer_thread = None
+        self._file_prefix = None
+        
+    @property
+    def file_name(self): 
+        suffix = "bdf" if self.resolution == 24 else "edf"
+        
+        # 文件名称
+        file_name = f"{self._file_prefix}_{self._device_no}_{self._start_time.strftime('%y%m%d%H%I%M')}.{suffix}" if self._file_prefix else f"{self._device_no}_{self._start_time.strftime('%y%m%d%H%I%M')}.{suffix}"
+        
+        if self._storage_path:
+            try:
+                # 自动创建目录，存在则忽略
+                os.makedirs(self._storage_path, exist_ok=True)  
+                
+                return f"{self._storage_path}/{file_name}"
+            except Exception as e:
+                logger.error(f"创建目录[{self._storage_path}]失败: {e}")            
+        
+        return file_name
+    
+    def set_device_type(self, device_type):
+        if device_type == 0x39:
+            self._device_type = "C64RS"
+        elif device_type == 0x40:
+            self._device_type = "LJ64S1"
+        else:
+            self._device_type = hex(device_type)
+        
+    def set_device_no(self, device_no):
+        self._device_no = device_no
+        
+    def set_storage_path(self, storage_path):
+        self._storage_path = storage_path
+        
+    def set_file_prefix(self, file_prefix):
+        self._file_prefix = file_prefix
+        
+    def set_patient_code(self, patient_code):
+        self._patient_code = patient_code
+        
+    def set_patient_name(self, patient_name):
+        self._patient_name = patient_name
+    
+    def write(self, packet: RscPacket):
+        logger.debug(f"packet: {packet}")    
+        if packet is None:
+            self._edf_writer_thread.stop_recording()
+            return
+    
+        if self.channels is None:
+            logger.info(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}")
+            
+        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
+            logger.warning(f"数据包丢失: {self._last_pkg_id} -> {packet.pkg_id}, 丢包数: {packet.pkg_id - self._last_pkg_id - 1}")
+            
+        self._last_pkg_id = packet.pkg_id
+        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.set_start_time(self._start_time)
+            self._edf_writer_thread.start()
+            logger.info(f"开始写入数据: {self.file_name}")
+            
+        self._edf_writer_thread.append(packet.eeg)
+            
+    
+    # trigger标记
+    # desc: 标记内容
+    # cur_time: 设备时间时间戳，非设备发出的trigger不要设置
+    def trigger(self, desc, cur_time=None):
+        if cur_time is None:
+            onset = datetime.now().timestamp() - self._start_time.timestamp()
+        else:
+            onset = cur_time - self._first_timestamp
+        self._edf_writer_thread.trigger(onset, desc)     
+    

qlsdk2-0.4.1/src/qlsdk/rsc/__init__.py

@@ -0,0 +1,9 @@
+from .network.discover import *
+
+from .entity import DeviceParser, QLDevice
+from .command import *
+# from .device_manager import DeviceContainer
+from .proxy import DeviceProxy
+from .paradigm import *
+from .manager import DeviceContainer
+from .network import *