qlsdk2 0.3.0a2__py3-none-any.whl → 0.3.0a3__py3-none-any.whl

{qlsdk2-0.3.0a2.dist-info → qlsdk2-0.3.0a3.dist-info}/METADATA

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

{qlsdk2-0.3.0a2.dist-info → qlsdk2-0.3.0a3.dist-info}/RECORD

@@ -1,18 +1,16 @@
 qlsdk/__init__.py,sha256=w0UCnZJekAq4orDahQXRL8s5JJGrWMz0De5LVIf4X_c,426
 qlsdk/ar4/__init__.py,sha256=iR0bFanDwqSxSEM1nCcge1l-GSIWjwnMeRQa47wGrds,4752
 qlsdk/ar4m/__init__.py,sha256=Z13X53WKmKp6MW_fA1FUPdQgJxhxxuyzemJWPS_CEHA,639
-qlsdk/ar4m/ar4sdk.py,sha256=OtmlvbO7XAgk5FNPFYIv_rXGj14maaWtgi2lQ7zQkvY,41418
-qlsdk/ar4m/persist.py,sha256=YrISKVfY-r1m2GZOw-JLuqTbEajA5wYa31MejGlz14I,6696
-qlsdk/ar4m/libs/libAr4SDK.dll,sha256=kZp9_DRwPdAJ5OgTFQSqS8tEETxUs7YmmETuBP2g60U,15402132
-qlsdk/ar4m/libs/libwinpthread-1.dll,sha256=W77ySaDQDi0yxpnQu-ifcU6-uHKzmQpcvsyx2J9j5eg,52224
 qlsdk/persist/__init__.py,sha256=UYaNL_RSczIZL_YrBWAifoAnNxpgZHEeSp-goHqyqv4,27
 qlsdk/persist/edf.py,sha256=usgFjZJVcfAUwSy6cJtRdgjdqMgOS4viLCDGcwAGMZE,7106
 qlsdk/sdk/__init__.py,sha256=v9LKP-5qXCqnAsCkiRE9LDb5Tagvl_Qd_fqrw7y9yd4,68
 qlsdk/sdk/ar4sdk.py,sha256=ZILuUVgUZN7-LNQm4xdItxmZWGwvFt4oWUKGez1BCLI,27101
 qlsdk/sdk/hub.py,sha256=uEOGZBZtMDCWlV8G2TZe6FAo6eTPcwHAW8zdqr1eq_0,1571
+qlsdk/sdk/libs/libAr4SDK.dll,sha256=kZp9_DRwPdAJ5OgTFQSqS8tEETxUs7YmmETuBP2g60U,15402132
+qlsdk/sdk/libs/libwinpthread-1.dll,sha256=W77ySaDQDi0yxpnQu-ifcU6-uHKzmQpcvsyx2J9j5eg,52224
 qlsdk/x8/__init__.py,sha256=XlQn3Af_HA7bGrxhv3RZKWMob_SnmissXiso7OH1UgI,4750
 qlsdk/x8m/__init__.py,sha256=cLeUqEEj65qXw4Qa4REyxoLh6T24anSqPaKe9_lR340,634
-qlsdk2-0.3.0a2.dist-info/METADATA,sha256=o6ms9sTAOlaWyWyGuLc0IWYvFYu1oXXVDhqNMixvpqI,7066
-qlsdk2-0.3.0a2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-qlsdk2-0.3.0a2.dist-info/top_level.txt,sha256=2CHzn0SY-NIBVyBl07Suh-Eo8oBAQfyNPtqQ_aDatBg,6
-qlsdk2-0.3.0a2.dist-info/RECORD,,
+qlsdk2-0.3.0a3.dist-info/METADATA,sha256=FE9C1YckDtBRsYXY6VInPhcf_WT5X1D-t_FO7WL-MUc,7066
+qlsdk2-0.3.0a3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+qlsdk2-0.3.0a3.dist-info/top_level.txt,sha256=2CHzn0SY-NIBVyBl07Suh-Eo8oBAQfyNPtqQ_aDatBg,6
+qlsdk2-0.3.0a3.dist-info/RECORD,,

qlsdk/ar4m/ar4sdk.py

@@ -1,1011 +0,0 @@
-import ctypes
-from multiprocessing import Queue
-import platform
-from ctypes import (
-    c_int, c_int32, c_int64, c_uint32, c_uint64, 
-    c_char, c_char_p, c_void_p, c_double,
-    Structure, POINTER, CFUNCTYPE
-)
-from typing import Literal
-from loguru import logger
-from time import sleep, time
-import os 
-import numpy as np
-from .persist import EdfHandler
-
-real_path = os.path.realpath(__file__)
-dll_path = f'{os.path.dirname(real_path)}/libs/libAr4SDK.dll'
-
-# 加载 DLL
-if platform.system() == 'Windows':
-    _dll = ctypes.CDLL(dll_path)
-else:
-    raise NotImplementedError(f"不支持非Windows平台：{platform.system()}")
-
-#------------------------------------------------------------------
-# 基础类型定义
-#------------------------------------------------------------------
-class Ar4MacStr(Structure):
-    _fields_ = [("str", c_char * 17)]
-
-class Ar4Name(Structure):
-    _fields_ = [("str", c_char * 21)]
-
-class Ar4Device(Structure):
-    _fields_ = [
-        ("slot", c_int32),
-        ("mac", c_uint64),
-        ("hub_name", Ar4Name)
-    ]
-
-class Ar4NotifyData(Structure):
-    _fields_ = [
-        ("time_stamp", c_int64),
-        ("pkg_id", c_int64),
-        ("notify_id", c_int64),
-        ("eeg", POINTER(c_int32)),
-        ("eeg_ch_count", c_int32),
-        ("eeg_count", c_int32),
-        ("acc", POINTER(c_int32)),
-        ("acc_ch_count", c_int32),
-        ("acc_count", c_int32)
-    ]
-
-#------------------------------------------------------------------
-# 回调函数类型
-#------------------------------------------------------------------
-FuncAr4DataNotify = CFUNCTYPE(None, c_void_p, POINTER(Ar4NotifyData))
-FuncAr4TriggerNotify = CFUNCTYPE(None, c_void_p, c_int64, c_int32, c_uint32)
-FuncAr4RecorderDisconnected = CFUNCTYPE(None, c_void_p)
-FuncAr4RecorderConnected = CFUNCTYPE(None, c_void_p)
-FuncAr4RecorderTimeout = CFUNCTYPE(None, c_void_p, c_int64)
-FuncAr4RecorderPkgLost = CFUNCTYPE(c_int, c_void_p, c_int64, c_int64, c_int64)
-FuncAr4GetTime = CFUNCTYPE(c_int64)
-FuncAr4SDKPrint = CFUNCTYPE(None, c_char_p, ctypes.c_size_t)
-
-#------------------------------------------------------------------
-# SDK 函数定义
-#------------------------------------------------------------------
-# 设备枚举
-_dll.ar4_sdk_enum_device.restype = POINTER(Ar4Device)
-_dll.ar4_sdk_enum_hub.restype = POINTER(Ar4Name)
-_dll.ar4_sdk_enum_in_hub.argtypes = [Ar4Name]
-
-# MAC地址转换
-_dll.ar4_mac_to_str.argtypes = [c_uint64]
-_dll.ar4_mac_to_str.restype = Ar4MacStr
-_dll.ar4_str_to_mac.argtypes = [Ar4MacStr]
-_dll.ar4_str_to_mac.restype = c_uint64
-
-# 连接管理
-_dll.ar4_sdk_connect.argtypes = [c_uint64, c_void_p]
-_dll.ar4_sdk_connect.restype = c_void_p
-_dll.ar4_sdk_disconnect.argtypes = [c_void_p]
-
-# AR4信息查询
-_dll.ar4_sdk_get_box_name.argtypes = [c_void_p]
-_dll.ar4_sdk_get_box_name.restype = c_uint64
-
-# 数据采集控制
-_dll.ar4_sdk_start_acq.argtypes = [c_void_p]
-_dll.ar4_sdk_start_acq.restype = c_int
-_dll.ar4_sdk_stop_acq.argtypes = [c_void_p]
-_dll.ar4_sdk_stop_acq.restype = c_int
-_dll.ar4_sdk_get_record_sample_rate.argtypes = [c_void_p]
-_dll.ar4_sdk_get_record_sample_rate.restype = c_double
-_dll.ar4_sdk_get_acq_start_time.argtypes = [c_void_p]
-_dll.ar4_sdk_get_acq_start_time.restype = c_int64
-
-# eeg信号物理量转换
-_dll.ar4_sdk_get_eeg_phy_max.argtypes = [c_void_p]
-_dll.ar4_sdk_get_eeg_phy_max.restype = c_double
-_dll.ar4_sdk_get_eeg_phy_min.argtypes = [c_void_p]
-_dll.ar4_sdk_get_eeg_phy_min.restype = c_double
-_dll.ar4_sdk_get_eeg_digtal_max.argtypes = [c_void_p]
-_dll.ar4_sdk_get_eeg_digtal_max.restype = c_int32
-_dll.ar4_sdk_get_eeg_digtal_min.argtypes = [c_void_p]
-_dll.ar4_sdk_get_eeg_digtal_min.restype = c_int32
-_dll.ar4_sdk_get_eeg_phy_unit.argtypes = [c_void_p]
-_dll.ar4_sdk_get_eeg_phy_unit.restype = c_char_p
-
-# acc信号物理量转换
-_dll.ar4_sdk_get_acc_phy_max.argtypes = [c_void_p]
-_dll.ar4_sdk_get_acc_phy_max.restype = c_double
-_dll.ar4_sdk_get_acc_phy_min.argtypes = [c_void_p]
-_dll.ar4_sdk_get_acc_phy_min.restype = c_double
-_dll.ar4_sdk_get_acc_digtal_max.argtypes = [c_void_p]
-_dll.ar4_sdk_get_acc_digtal_max.restype = c_int32
-_dll.ar4_sdk_get_acc_digtal_min.argtypes = [c_void_p]
-_dll.ar4_sdk_get_acc_digtal_min.restype = c_int32
-_dll.ar4_sdk_get_acc_phy_unit.argtypes = [c_void_p]
-_dll.ar4_sdk_get_acc_phy_unit.restype = c_char_p
-
-# 回调注册
-_dll.ar4_sdk_register_data_notify.argtypes = [c_void_p, FuncAr4DataNotify]
-_dll.ar4_sdk_register_data_notify.restype = None
-_dll.ar4_sdk_register_trigger_notify.argtypes = [c_void_p, c_void_p]
-_dll.ar4_sdk_register_conn_notify.argtypes = [c_void_p, FuncAr4RecorderConnected, FuncAr4RecorderDisconnected]
-_dll.ar4_sdk_register_record_state_notify.argtypes = [c_void_p, FuncAr4RecorderConnected, FuncAr4RecorderDisconnected]
-_dll.ar4_sdk_register_box_conn_notify.argtypes = [c_void_p, FuncAr4RecorderConnected, FuncAr4RecorderDisconnected]
-
-# _dll对外封装类
-class AR4SDK:
-    @classmethod
-    def enum_devices(cls):
-        """枚举可用设备"""
-        devices = []
-        ptr = _dll.ar4_sdk_enum_device()
-        if not ptr:
-            logger.info("没有找到ar4设备")
-            return devices
-        
-        index = 0
-        while True:
-            device = ptr[index]
-            if not device or device.mac == 0:
-                break
-            # logger.debug(f"get device: {device.slot}, mac: {hex(device.mac)}, hub_name: {device.hub_name.str}")
-            devices.append(device)
-            index += 1
-            
-        return devices
-    
-    @classmethod
-    def enum_hubs(cls):
-        """枚举可用设备"""
-        devices = []
-        ptr = _dll.ar4_sdk_enum_hub()
-        sleep(5)
-        logger.debug(f"enum_hubs: {ptr}")
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
-
-# 读取系统当前时间(ms)
-def _get_time():
-    cur_time = int(round(time()) * 1000)
-    return cur_time  
-
-class LMDevice(object):
-    def __init__(self, box_mac:str, slot:int, hub_name:str):
-        # 设备句柄
-        self._handle = None
-        # 设备基本信息
-        self._box_type = None
-        self._box_mac = box_mac
-        self._box_id = None
-        self._box_soc = None
-        self._box_name = None
-        self._box_version = None
-        self._head_type = None
-        self._head_mac = None
-        self._head_version = None
-        self._head_conn_state = None
-        self._head_soc = None
-        self._net_state = None
-        self._hub_name = hub_name
-        self._slot = slot
-        self._connected = False
-        self._conn_time = None
-        self._last_time = None
-        
-        self._recording = False
-        self._record_start_time = None
-        
-        ## eeg 数据
-        self._eeg_phy_max = None
-        self._eeg_phy_min = None
-        self._eeg_dig_max = None
-        self._eeg_dig_min = None
-        self._eeg_phy_unit = 'uV'
-        self._eeg_phy_range = None
-        self._eeg_dig_range = None
-        ## acc 数据
-        self._acc_phy_max = None    
-        self._acc_phy_min = None
-        self._acc_dig_max = None
-        self._acc_dig_min = None
-        self._acc_phy_unit = 'mG'
-        self._acc_phy_range = None
-        self._acc_dig_range = None
-        
-        self._acq_info = {}
-        # 订阅者列表，数值为数字信号值
-        self._dig_subscriber: dict[str, Queue] = {}
-        # 订阅者列表，数值为物理信号值
-        self._phy_subscriber: dict[str, Queue] = {}
-        
-        # 回调函数
-        self._data_callback = FuncAr4DataNotify(self._wrap_data_accept())        
-        self._trigger_callback = FuncAr4TriggerNotify(self._wrap_trigger_accept())
-        self._connected_notify_callback = FuncAr4RecorderConnected(self._wrap_connected_notify())
-        self._disconnected_notify_callback = FuncAr4RecorderDisconnected(self._wrap_disconnected_notify())
-        self._box_connected_notify_callback = FuncAr4RecorderConnected(self._wrap_box_connected_notify())
-        self._box_disconnected_notify_callback = FuncAr4RecorderDisconnected(self._wrap_box_disconnected_notify())
-        self._start_record_notify_callback = FuncAr4RecorderConnected(self._wrap_start_record_notify())
-        self._stop_record_notify_callback = FuncAr4RecorderDisconnected(self._wrap_stop_record_notify())
-        
-    @property
-    def box_mac(self):
-        return self._box_mac
-    @property
-    def slot(self):
-        return self._slot
-    @property
-    def hub_name(self):
-        return self._hub_name
-    def init(self):
-        # logger.info(f"init ar4 {self.box_mac}")
-        if not self._handle:
-            self._connected = self.connect()
-            ## eeg 参数
-            self._eeg_phy_max = _dll.ar4_sdk_get_eeg_phy_max(self._handle)
-            self._eeg_phy_min = _dll.ar4_sdk_get_eeg_phy_min(self._handle)
-            self._eeg_dig_max = _dll.ar4_sdk_get_eeg_digtal_max(self._handle)
-            self._eeg_dig_min = _dll.ar4_sdk_get_eeg_digtal_min(self._handle)
-            self._eeg_phy_range = self._eeg_phy_max - self._eeg_phy_min
-            self._eeg_dig_range = self._eeg_dig_max - self._eeg_dig_min
-            eeg_unit = _dll.ar4_sdk_get_eeg_phy_unit(self._handle)
-            if eeg_unit:
-                try:
-                    self._eeg_phy_unit = eeg_unit.decode("utf-8")
-                except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取eeg物理单位异常: {str(e)}")
-            
-            ## acc 参数
-            self._acc_phy_max = _dll.ar4_sdk_get_acc_phy_max(self._handle)    
-            self._acc_phy_min = _dll.ar4_sdk_get_acc_phy_min(self._handle)
-            self._acc_dig_max = _dll.ar4_sdk_get_acc_digtal_max(self._handle)
-            self._acc_dig_min = _dll.ar4_sdk_get_acc_digtal_min(self._handle)
-            self._acc_phy_range = self._acc_phy_max - self._acc_phy_min
-            self._acc_dig_range = self._acc_dig_max - self._acc_dig_min
-            acc_unit = _dll.ar4_sdk_get_acc_phy_unit(self._handle)
-            if acc_unit:
-                try:
-                    self._acc_phy_unit = eeg_unit.decode("utf-8")
-                except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取acc物理单位异常: {str(e)}")
-            
-            if self._connected:
-                self._conn_time = _get_time()
-                self.get_box_name()
-                self.get_head_mac()
-                self.get_record_conn_state()
-                self._last_time = _get_time()
-            logger.debug(self)
-            self._register_callback()
-        return True
-    
-    def _register_callback(self):
-        try:
-            _dll.ar4_sdk_register_data_notify(self._handle, self._data_callback)
-            _dll.ar4_sdk_register_trigger_notify(self._handle, self._trigger_callback)
-            _dll.ar4_sdk_register_conn_notify(self._handle, self._connected_notify_callback, self._disconnected_notify_callback)
-            _dll.ar4_sdk_register_record_state_notify(self._handle, self._start_record_notify_callback, self._stop_record_notify_callback)
-            _dll.ar4_sdk_register_box_conn_notify(self._handle, self._box_connected_notify_callback, self._box_disconnected_notify_callback)
-        except Exception as e:
-            logger.error(f"回调函数注册异常: {str(e)}")
-
-    def update_info(self):
-        self._last_time = _get_time()
-        
-    # 设备连接
-    def connect(self)-> bool:
-        
-            if self._box_mac:
-                """连接设备"""
-                # callback = FuncAr4GetTime(self._get_time)
-                try:
-                    self._handle = _dll.ar4_sdk_connect(int(self._box_mac, 16), c_void_p(0))
-                    # logger.info(f"conn handle is {self._handle}")
-                    self._handle = c_void_p(self._handle)     
-                    logger.debug(f"ar4 {self._box_mac} 连接: {self._handle}")                   
-                except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 连接异常: {str(e)}")
-            return self._handle is not None
-    
-    # 读取盒子名称
-    def get_box_name(self):
-        if self._handle:    
-            try:        
-                self._head_mac = _dll.ar4_sdk_get_recoder_mac(self._handle)
-            except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取盒子记录子mac异常: {str(e)}")
-    # 读取记录子mac
-    def get_head_mac(self):
-        if self._handle:    
-            try:        
-                self._box_name = _dll.ar4_sdk_get_record_conn_state(self._handle)
-            except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取盒子名称异常: {str(e)}")
-    # 读取记录子连接状态
-    def get_record_conn_state(self):
-        if self._handle:    
-            try:        
-                self._head_conn_state = _dll.ar4_sdk_get_record_conn_state(self._handle)
-            except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取盒子记录子连接状态异常: {str(e)}")
-
-    # 数据采集启动
-    def start_acquisition(self):
-        logger.info(f"ar4 {self._box_mac} 启动数据采集...")
-        """启动数据采集"""
-        
-        self._acq_info["start_time"] = _get_time()
-        
-        if self._handle:
-            # 启动采集
-            try:
-                logger.debug(f"ar4 {self._box_mac} 启动采集: {self._handle}")
-                ret = _dll.ar4_sdk_start_acq(self._handle)
-                logger.debug(f"ar4 {self._box_mac} 启动采集结果: {ret}")
-                    
-                return ret == 0
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
-        else:
-            logger.info(f"ar4 {self._box_mac} 启动数据采集失败， 设备未连接")
-            return False
-
-    def stop_acquisition(self):
-        """停止采集"""
-        if self._handle:
-            try:                
-                self.get_acq_start_time() 
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 获取开始采集时间异常: {str(e)}")
-            try:
-                return _dll.ar4_sdk_stop_acq(self._handle) == 0
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
-        else:
-            return False
-
-    def disconnect(self):
-        """断开连接"""
-        if self._handle:
-            _dll.ar4_sdk_disconnect(self._handle)
-
-    def get_sample_rate(self):
-        try:
-            ret = _dll.ar4_sdk_get_record_sample_rate(self._handle)
-            logger.debug(f"ar4 {self._box_mac} 获取采样率: {ret.contents.decode('utf-8')}")
-        except Exception as e:
-            logger.error(f"ar4 {self._box_mac} 获取采样率异常: {str(e)}")
-            
-    def get_acq_start_time(self):
-        try:
-            ret = _dll.ar4_sdk_get_acq_start_time(self._handle)
-            # 更新采样开始时间
-            if ret:
-                self._acq_info["start_time"] = ret
-            logger.debug(f"ar4 {self._box_mac} 获取采样开始时间: {ret}")
-        except Exception as e:
-            logger.error(f"ar4 {self._box_mac} 获取采样开始时间异常: {str(e)}")
-       
-    # 订阅推送消息 
-    def subscribe(self, topic: str = None, q: Queue = Queue(), value_type: Literal['phy', 'dig'] = 'phy') -> tuple[str, Queue]:
-        if topic is None:
-            topic = f"msg_{_get_time()}"
-        
-        if value_type == 'dig':
-            if topic in list(self._dig_subscriber.keys()):  
-                logger.warning(f"ar4 {self._box_mac} 订阅主题已存在: {topic}")
-                return topic, self._dig_subscriber[topic]
-            self._dig_subscriber[topic] = q
-        else:
-            if topic in list(self._phy_subscriber.keys()):  
-                logger.warning(f"ar4 {self._box_mac} 订阅主题已存在: {topic}")
-                return topic, self._phy_subscriber[topic]
-            self._phy_subscriber[topic] = q
-        
-        return topic, q
-    
-    def _wrap_data_accept(self):
-        
-        @FuncAr4DataNotify
-        def data_accept(handle, data_ptr):
-            self._data_accept(data_ptr)
-            
-        return data_accept
-    def _data_accept(self, data_ptr):
-        # logger.info(f"_eeg_accept 被调用")
-        # logger.debug(f'handle:{self}, data_ptr:{data_ptr}')
-        # data = cast(data_ptr, POINTER(Ar4NotifyData)).contents
-        if len(self._dig_subscriber) > 0 or len(self._phy_subscriber) > 0:
-            packet = AR4Packet().transfer(data_ptr.contents)
-            
-            for consumer in self._dig_subscriber.values():
-                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}")
-                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}")
-                for consumer2 in self._phy_subscriber.values():
-                    consumer2.put(packet)
-        
-            # logger.debug(f"EEG数据: {packet}")
-    
-    def eeg2phy(self, digtal):
-        # 向量化计算（自动支持广播）
-        return ((digtal - self._eeg_dig_min) / self._eeg_dig_range) * self._eeg_phy_range + self._eeg_phy_min
-    
-    def acc2phy(self, digtal):
-        return ((digtal - self._acc_dig_min) / self._acc_dig_range) * self._acc_phy_range + self._acc_phy_min
-    def _wrap_trigger_accept(self):
-        
-        @FuncAr4DataNotify
-        def trigger_accept(handle, time_ms, trigger_type, trigger_value):
-            self._trigger_accept(time_ms, trigger_type, trigger_value)
-            
-        return trigger_accept
-        
-    def _trigger_accept(self, time_ms, trigger_type, trigger_value):
-        logger.info(f"_trigger_accept 被调用")
-        logger.info(f"触发时间: {time_ms}, 触发类型: {trigger_type}, 触发值: {trigger_value}")
-        
-        
-    def _wrap_connected_notify(self):
-        
-        @FuncAr4RecorderConnected
-        def connected_notify(handle):
-            self._connected_notify(handle)
-            
-        return connected_notify      
-    
-    def _connected_notify(self, handle):
-        logger.info(f"_connected_notify 被调用 handle: {handle}")
-        
-        
-    def _wrap_disconnected_notify(self):
-        @FuncAr4RecorderDisconnected
-        def disconnected_notify(handle):
-            self._disconnected_notify(handle)
-            
-        return disconnected_notify      
-    
-    def _disconnected_notify(self, handle):
-        logger.info(f"_disconnected_notify 被调用 handle: {handle}")
-        
-        
-    def _wrap_box_connected_notify(self):
-        
-        @FuncAr4RecorderConnected
-        def box_connected_notify(handle):
-            self._box_connected_notify(handle)
-            
-        return box_connected_notify      
-    
-    def _box_connected_notify(self, handle):
-        logger.info(f"_box_connected_notify 被调用 handle: {handle}")
-        
-    def _wrap_box_disconnected_notify(self):
-        @FuncAr4RecorderDisconnected
-        def box_disconnected_notify(handle):
-            self._box_disconnected_notify(handle)
-            
-        return box_disconnected_notify      
-    
-    def _box_disconnected_notify(self, handle):
-        logger.info(f"_box_disconnected_notify 被调用 handle: {handle}")
-        
-    def _wrap_start_record_notify(self):
-        
-        @FuncAr4RecorderConnected
-        def start_record_notify(handle):
-            self._start_record_notify(handle)
-            
-        return start_record_notify      
-    
-    def _start_record_notify(self, handle):
-        logger.info(f"_start_record_notify 被调用 handle: {handle}")        
-        self._recording = True
-        self._record_start_time = time()
-        logger.info(self)
-        
-        
-    def _wrap_stop_record_notify(self):
-        @FuncAr4RecorderDisconnected
-        def stop_record_notify(handle):
-            self._stop_record_notify(handle)
-            
-        return stop_record_notify      
-    
-    def _stop_record_notify(self, handle):
-        logger.info(f"_stop_record_notify 被调用 handle: {handle}")      
-        self._recording = False
-        
-    def __str__(self):
-        return f"""
-                box mac: {self._box_mac}, 
-                box name: {self._box_name}, 
-                box soc: {self._box_soc}
-                head conn state: {self._head_conn_state}
-                head mac: {self._head_mac},
-                head soc: {self._head_soc} 
-                connected: {self._connected}
-                connect time: {self._conn_time}
-                last time: {self._last_time}
-                [
-                eeg phy max: {self._eeg_phy_max}
-                eeg phy min: {self._eeg_phy_min}
-                eeg dig max: {self._eeg_dig_max}
-                eeg dig min: {self._eeg_dig_min}
-                eeg phy unit: {self._eeg_phy_unit}
-                ]
-                [
-                acc phy max: {self._acc_phy_max}
-                acc phy min: {self._acc_phy_min}
-                acc dig max: {self._acc_dig_max}
-                acc dig min: {self._acc_dig_min}
-                acc phy unit: {self._acc_phy_unit}
-                ]
-                dig -> ((dig - {self._eeg_dig_min}) / {self._eeg_dig_range}) * {self._eeg_phy_range} + {self._eeg_phy_min}
-                dig -> ((dig - {self._acc_dig_min}) / {self._acc_dig_range}) * {self._acc_phy_range} + {self._acc_phy_min}
-            """
-            
-    
-    
-# ar4设备对象
-class AR4(object):
-    def __init__(self, box_mac:str, slot:int=None, hub_name:str=None, is_persist:bool=True, storage_path:str=None):
-        # 是否持久化-保存为文件
-        self._is_persist = is_persist
-        self._storage_path = storage_path
-        self._edf_handler = None
-        # 设备句柄
-        self._handle = None
-        
-        self.box_connected = False
-        self.sample_frequency = 500
-        # 设备基本信息
-        self._box_type = None
-        self._box_mac = box_mac
-        self._box_id = None
-        self._box_soc = None
-        self._box_name = None
-        self._box_version = None
-        self._head_type = None
-        self._head_mac = None
-        self._head_version = None
-        self._head_conn_state = None
-        self._head_soc = None
-        self._net_state = None
-        self._hub_name = hub_name
-        self._slot = slot
-        self._connected = False
-        self._conn_time = None
-        self._last_time = None
-        
-        self._recording = False
-        self._record_start_time = None
-        
-        ## eeg 数据
-        self._eeg_phy_max = None
-        self._eeg_phy_min = None
-        self._eeg_dig_max = None
-        self._eeg_dig_min = None
-        self._eeg_phy_unit = 'uV'
-        self._eeg_phy_range = None
-        self._eeg_dig_range = None
-        ## acc 数据
-        self._acc_phy_max = None    
-        self._acc_phy_min = None
-        self._acc_dig_max = None
-        self._acc_dig_min = None
-        self._acc_phy_unit = 'mG'
-        self._acc_phy_range = None
-        self._acc_dig_range = None
-        
-        self._acq_info = {}
-        # 订阅者列表，数值为数字信号值
-        self._dig_subscriber: dict[str, Queue] = {}
-        # 订阅者列表，数值为物理信号值
-        self._phy_subscriber: dict[str, Queue] = {}
-        
-        # 回调函数
-        self._data_callback = FuncAr4DataNotify(self._wrap_data_accept())        
-        self._trigger_callback = FuncAr4TriggerNotify(self._wrap_trigger_accept())
-        self._connected_notify_callback = FuncAr4RecorderConnected(self._wrap_connected_notify())
-        self._disconnected_notify_callback = FuncAr4RecorderDisconnected(self._wrap_disconnected_notify())
-        self._box_connected_notify_callback = FuncAr4RecorderConnected(self._wrap_box_connected_notify())
-        self._box_disconnected_notify_callback = FuncAr4RecorderDisconnected(self._wrap_box_disconnected_notify())
-        self._start_record_notify_callback = FuncAr4RecorderConnected(self._wrap_start_record_notify())
-        self._stop_record_notify_callback = FuncAr4RecorderDisconnected(self._wrap_stop_record_notify())
-        
-    @property
-    def box_mac(self):
-        return self._box_mac
-    @property
-    def slot(self):
-        return self._slot
-    @property
-    def hub_name(self):
-        return self._hub_name
-    
-    def set_storage_path(self, storage_path):
-        self._storage_path = storage_path
-
-    def init(self):
-        # logger.info(f"init ar4 {self.box_mac}")
-        if not self._handle:
-            self._connected = self.connect()
-            ## eeg 参数
-            self._eeg_phy_max = _dll.ar4_sdk_get_eeg_phy_max(self._handle)
-            self._eeg_phy_min = _dll.ar4_sdk_get_eeg_phy_min(self._handle)
-            self._eeg_dig_max = _dll.ar4_sdk_get_eeg_digtal_max(self._handle)
-            self._eeg_dig_min = _dll.ar4_sdk_get_eeg_digtal_min(self._handle)
-            self._eeg_phy_range = self._eeg_phy_max - self._eeg_phy_min
-            self._eeg_dig_range = self._eeg_dig_max - self._eeg_dig_min
-            eeg_unit = _dll.ar4_sdk_get_eeg_phy_unit(self._handle)
-            if eeg_unit:
-                try:
-                    self._eeg_phy_unit = eeg_unit.decode("utf-8")
-                except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取eeg物理单位异常: {str(e)}")
-            
-            ## acc 参数
-            self._acc_phy_max = _dll.ar4_sdk_get_acc_phy_max(self._handle)    
-            self._acc_phy_min = _dll.ar4_sdk_get_acc_phy_min(self._handle)
-            self._acc_dig_max = _dll.ar4_sdk_get_acc_digtal_max(self._handle)
-            self._acc_dig_min = _dll.ar4_sdk_get_acc_digtal_min(self._handle)
-            self._acc_phy_range = self._acc_phy_max - self._acc_phy_min
-            self._acc_dig_range = self._acc_dig_max - self._acc_dig_min
-            acc_unit = _dll.ar4_sdk_get_acc_phy_unit(self._handle)
-            if acc_unit:
-                try:
-                    self._acc_phy_unit = eeg_unit.decode("utf-8")
-                except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取acc物理单位异常: {str(e)}")
-            
-            if self._connected:
-                self._conn_time = _get_time()
-                self.get_box_name()
-                self.get_head_mac()
-                self.get_record_conn_state()
-                self._last_time = _get_time()
-            logger.debug(self)
-            self._register_callback()
-        return True
-    
-    def _register_callback(self):
-        try:
-            _dll.ar4_sdk_register_data_notify(self._handle, self._data_callback)
-            _dll.ar4_sdk_register_trigger_notify(self._handle, self._trigger_callback)
-            _dll.ar4_sdk_register_conn_notify(self._handle, self._connected_notify_callback, self._disconnected_notify_callback)
-            _dll.ar4_sdk_register_record_state_notify(self._handle, self._start_record_notify_callback, self._stop_record_notify_callback)
-            _dll.ar4_sdk_register_box_conn_notify(self._handle, self._box_connected_notify_callback, self._box_disconnected_notify_callback)
-        except Exception as e:
-            logger.error(f"回调函数注册异常: {str(e)}")
-
-    @property
-    def device_type(self):
-        return "ar4" if self._box_type == 4  else "x8" if self._box_type == 8 else "lm"
-    
-    def update_info(self):
-        logger.debug(f"update info {self._box_mac}")
-        self._last_time = _get_time()
-        
-    # 设备连接
-    def connect(self)-> bool:
-        
-            if self._box_mac:
-                """连接设备"""
-                # callback = FuncAr4GetTime(self._get_time)
-                try:
-                    self._handle = _dll.ar4_sdk_connect(int(self._box_mac, 16), c_void_p(0))
-                    # logger.info(f"conn handle is {self._handle}")
-                    self._handle = c_void_p(self._handle)     
-                    logger.debug(f"ar4 {self._box_mac} 连接: {self._handle}")                   
-                except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 连接异常: {str(e)}")
-            return self._handle is not None
-    
-    # 读取盒子名称
-    def get_box_name(self):
-        if self._handle:    
-            try:        
-                self._head_mac = _dll.ar4_sdk_get_recoder_mac(self._handle)
-            except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取盒子记录子mac异常: {str(e)}")
-    # 读取记录子mac
-    def get_head_mac(self):
-        if self._handle:    
-            try:        
-                self._box_name = _dll.ar4_sdk_get_record_conn_state(self._handle)
-            except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取盒子名称异常: {str(e)}")
-    # 读取记录子连接状态
-    def get_record_conn_state(self):
-        if self._handle:    
-            try:        
-                self._head_conn_state = _dll.ar4_sdk_get_record_conn_state(self._handle)
-            except Exception as e:
-                    logger.error(f"ar4 {self._box_mac} 获取盒子记录子连接状态异常: {str(e)}")
-
-    # 数据采集启动
-    def start_acquisition(self):
-        logger.info(f"ar4 {self._box_mac} 启动数据采集...")
-        """启动数据采集"""
-        
-        self._acq_info["start_time"] = _get_time()
-        
-        if self._handle:
-            # 启动采集
-            try:
-                logger.debug(f"ar4 {self._box_mac} 启动采集: {self._handle}")
-                ret = _dll.ar4_sdk_start_acq(self._handle)
-                logger.debug(f"ar4 {self._box_mac} 启动采集结果: {ret}")
-                if (self._is_persist):
-                    self._edf_handler = EdfHandler(self.sample_frequency, self._eeg_phy_max, self._eeg_phy_min, self._eeg_dig_max, self._eeg_dig_min, storage_path = self._storage_path)
-                    self._edf_handler.set_device_type(self.device_type)
-                    
-                return ret == 0
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 启动数据采集异常: {str(e)}")
-        else:
-            logger.info(f"ar4 {self._box_mac} 启动数据采集失败， 设备未连接")
-            return False
-
-    def stop_acquisition(self):
-        """停止采集"""
-        if self._handle:
-            try:                
-                self.get_acq_start_time() 
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 获取开始采集时间异常: {str(e)}")
-            try:
-                ret = _dll.ar4_sdk_stop_acq(self._handle)
-                if ret == 0 and self._edf_handler:
-                    self._edf_handler.append(None)
-                
-                return ret == 0
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
-        else:
-            return False
-
-    def disconnect(self):
-        """断开连接"""
-        if self._handle:
-            _dll.ar4_sdk_disconnect(self._handle)
-
-    def get_sample_rate(self):
-        try:
-            ret = _dll.ar4_sdk_get_record_sample_rate(self._handle)
-            logger.debug(f"ar4 {self._box_mac} 获取采样率: {ret.contents.decode('utf-8')}")
-        except Exception as e:
-            logger.error(f"ar4 {self._box_mac} 获取采样率异常: {str(e)}")
-            
-    def get_acq_start_time(self):
-        try:
-            ret = _dll.ar4_sdk_get_acq_start_time(self._handle)
-            # 更新采样开始时间
-            if ret:
-                self._acq_info["start_time"] = ret
-            logger.debug(f"ar4 {self._box_mac} 获取采样开始时间: {ret}")
-        except Exception as e:
-            logger.error(f"ar4 {self._box_mac} 获取采样开始时间异常: {str(e)}")
-       
-    # 订阅推送消息 
-    def subscribe(self, topic: str = None, q: Queue = Queue(), value_type: Literal['phy', 'dig'] = 'phy') -> tuple[str, Queue]:
-        if topic is None:
-            topic = f"msg_{_get_time()}"
-        
-        if value_type == 'dig':
-            if topic in list(self._dig_subscriber.keys()):  
-                logger.warning(f"ar4 {self._box_mac} 订阅主题已存在: {topic}")
-                return topic, self._dig_subscriber[topic]
-            self._dig_subscriber[topic] = q
-        else:
-            if topic in list(self._phy_subscriber.keys()):  
-                logger.warning(f"ar4 {self._box_mac} 订阅主题已存在: {topic}")
-                return topic, self._phy_subscriber[topic]
-            self._phy_subscriber[topic] = q
-        
-        return topic, q
-    
-    def _wrap_data_accept(self):
-        
-        @FuncAr4DataNotify
-        def data_accept(handle, data_ptr):
-            self._data_accept(data_ptr)
-            
-        return data_accept
-    def _data_accept(self, data_ptr):
-        # logger.info(f"_eeg_accept 被调用")
-        # logger.debug(f'handle:{self}, data_ptr:{data_ptr}')
-        # data = cast(data_ptr, POINTER(Ar4NotifyData)).contents
-        # if len(self._dig_subscriber) > 0 or len(self._phy_subscriber) > 0:
-        packet = AR4Packet().transfer(data_ptr.contents)
-        if self._edf_handler:
-            self._edf_handler.append(packet)
-        
-        for consumer in self._dig_subscriber.values():
-            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}")
-            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}")
-            for consumer2 in self._phy_subscriber.values():
-                consumer2.put(packet)
-        
-            # logger.debug(f"EEG数据: {packet}")
-    
-    def eeg2phy(self, digtal):
-        # 向量化计算（自动支持广播）
-        return ((digtal - self._eeg_dig_min) / self._eeg_dig_range) * self._eeg_phy_range + self._eeg_phy_min
-    
-    def acc2phy(self, digtal):
-        return ((digtal - self._acc_dig_min) / self._acc_dig_range) * self._acc_phy_range + self._acc_phy_min
-    def _wrap_trigger_accept(self):
-        
-        @FuncAr4DataNotify
-        def trigger_accept(handle, time_ms, trigger_type, trigger_value):
-            self._trigger_accept(time_ms, trigger_type, trigger_value)
-            
-        return trigger_accept
-        
-    def _trigger_accept(self, time_ms, trigger_type, trigger_value):
-        logger.info(f"_trigger_accept 被调用")
-        logger.info(f"触发时间: {time_ms}, 触发类型: {trigger_type}, 触发值: {trigger_value}")
-        
-        
-    def _wrap_connected_notify(self):
-        
-        @FuncAr4RecorderConnected
-        def connected_notify(handle):
-            self._connected_notify(handle)
-            
-        return connected_notify      
-    
-    def _connected_notify(self, handle):
-        logger.info(f"_connected_notify 被调用 handle: {handle}")
-        
-        
-    def _wrap_disconnected_notify(self):
-        @FuncAr4RecorderDisconnected
-        def disconnected_notify(handle):
-            self._disconnected_notify(handle)
-            
-        return disconnected_notify      
-    
-    def _disconnected_notify(self, handle):
-        logger.info(f"_disconnected_notify 被调用 handle: {handle}")
-        
-        
-    def _wrap_box_connected_notify(self):
-        
-        @FuncAr4RecorderConnected
-        def box_connected_notify(handle):
-            self._box_connected_notify(handle)
-            
-        return box_connected_notify      
-    
-    def _box_connected_notify(self, handle):
-        self.box_connected = True
-        logger.info(f"_box_connected_notify 被调用 handle: {handle}")
-        
-    def _wrap_box_disconnected_notify(self):
-        @FuncAr4RecorderDisconnected
-        def box_disconnected_notify(handle):
-            self._box_disconnected_notify(handle)
-            
-        return box_disconnected_notify      
-    
-    def _box_disconnected_notify(self, handle):        
-        self.box_connected = False
-        logger.info(f"_box_disconnected_notify 被调用 handle: {handle}")
-        
-    def _wrap_start_record_notify(self):
-        
-        @FuncAr4RecorderConnected
-        def start_record_notify(handle):
-            self._start_record_notify(handle)
-            
-        return start_record_notify      
-    
-    def _start_record_notify(self, handle):
-        logger.info(f"_start_record_notify 被调用 handle: {handle}")        
-        self._recording = True
-        self._record_start_time = time()
-        logger.info(self)
-        
-        
-    def _wrap_stop_record_notify(self):
-        @FuncAr4RecorderDisconnected
-        def stop_record_notify(handle):
-            self._stop_record_notify(handle)
-            
-        return stop_record_notify      
-    
-    def _stop_record_notify(self, handle):
-        logger.info(f"_stop_record_notify 被调用 handle: {handle}")      
-        self._recording = False
-        
-    def __str__(self):
-        return f"""
-                box mac: {self._box_mac}, 
-                box name: {self._box_name}, 
-                box soc: {self._box_soc}
-                head conn state: {self._head_conn_state}
-                head mac: {self._head_mac},
-                head soc: {self._head_soc} 
-                connected: {self._connected}
-                connect time: {self._conn_time}
-                last time: {self._last_time}
-                [
-                eeg phy max: {self._eeg_phy_max}
-                eeg phy min: {self._eeg_phy_min}
-                eeg dig max: {self._eeg_dig_max}
-                eeg dig min: {self._eeg_dig_min}
-                eeg phy unit: {self._eeg_phy_unit}
-                ]
-                [
-                acc phy max: {self._acc_phy_max}
-                acc phy min: {self._acc_phy_min}
-                acc dig max: {self._acc_dig_max}
-                acc dig min: {self._acc_dig_min}
-                acc phy unit: {self._acc_phy_unit}
-                ]
-                dig -> ((dig - {self._eeg_dig_min}) / {self._eeg_dig_range}) * {self._eeg_phy_range} + {self._eeg_phy_min}
-                dig -> ((dig - {self._acc_dig_min}) / {self._acc_dig_range}) * {self._acc_phy_range} + {self._acc_phy_min}
-            """
-            
-class Packet(object):
-    pass
-            
-class AR4Packet(Packet):
-    def __init__(self):
-        self.time_stamp = None
-        self.pkg_id = None
-        self.notify_id = None
-        self.eeg_ch_count = None
-        self.eeg_count = None
-        self.eeg = None
-        self.acc_ch_count = None
-        self.acc_count = None
-        self.acc = None
-    
-    def transfer(self, data: Ar4NotifyData):
-        self.time_stamp = data.time_stamp
-        self.pkg_id = data.pkg_id
-        self.notify_id = data.notify_id
-        self.eeg_ch_count = data.eeg_ch_count
-        self.eeg_count = data.eeg_count
-        self.acc_ch_count = data.acc_ch_count
-        self.acc_count = data.acc_count
-        # 读eeg数据
-        if self.eeg_ch_count and self.eeg_count:
-            self.eeg = [data.eeg[i:self.eeg_count*self.eeg_ch_count:self.eeg_ch_count] for i in range(self.eeg_ch_count)]
-        # 读acc数据
-        if self.acc_ch_count and self.acc_count:
-            self.acc = [[] for _ in range(self.acc_ch_count)]
-            for i in range(self.acc_ch_count):
-                self.acc[i] = [data.acc[j + (i * self.acc_count)] for j in range(self.acc_count)]
-        
-        return self
-        
-    def __str__(self):
-        return f"""
-            time_stamp: {self.time_stamp}
-            pkg_id: {self.pkg_id}
-            notify_id: {self.notify_id}
-            eeg_ch_count: {self.eeg_ch_count}
-            eeg_count: {self.eeg_count}
-            acc_ch_count: {self.acc_ch_count}
-            acc_count: {self.acc_count}
-            eeg: {self.eeg}
-            acc: {self.acc}
-        """

qlsdk/ar4m/persist.py

@@ -1,178 +0,0 @@
-from datetime import datetime
-from multiprocessing import Lock, Queue
-from pyedflib import FILETYPE_BDFPLUS, FILETYPE_EDFPLUS, EdfWriter
-from threading import Thread
-from loguru import logger
-import numpy as np
-import os
-
-class EdfHandler(object):
-    def __init__(self, sample_frequency, physical_max, physical_min, digital_max, digital_min, resolution=16, storage_path = None):
-        self.physical_max = physical_max
-        self.physical_min = physical_min
-        self.digital_max = digital_max
-        self.digital_min = digital_min
-        self.channels = None
-        self._cache = Queue()
-        self.resolution = resolution
-        self.sample_frequency = sample_frequency
-        # 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._end_time = None
-        self._patient_code = "patient_code"
-        self._patient_name = "patient_name"
-        self._device_type = None
-        self._total_packets = 0
-        self._lost_packets = 0
-        self._storage_path = storage_path
-        
-    @property
-    def file_name(self): 
-        if self._storage_path:
-            try:
-                os.makedirs(self._storage_path, exist_ok=True)  # 自动创建目录，存在则忽略
-                return f"{self._storage_path}/{self._device_type}_{self._first_timestamp}.edf"
-            except Exception as e:
-                logger.error(f"创建目录[{self._storage_path}]失败: {e}")
-            
-        return f"{self._device_type}_{self._first_timestamp}.edf"
-         
-    @property
-    def file_type(self):
-        return FILETYPE_BDFPLUS if self.resolution == 24 else FILETYPE_EDFPLUS
-    
-    def set_device_type(self, device_type):
-        self._device_type = device_type
-        
-    def set_storage_path(self, storage_path):
-        self._storage_path = storage_path
-        
-    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 append(self, data):
-        if data:
-            # 通道数
-            if self._first_pkg_id is None:
-                self.channels = data.eeg_ch_count
-                self._first_pkg_id = data.pkg_id
-                self._first_timestamp = data.time_stamp
-                
-            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
-                logger.warning(f"数据包丢失: {self._last_pkg_id} -> {data.pkg_id}, 丢包数: {data.pkg_id - self._last_pkg_id - 1}")
-                
-            self._last_pkg_id = data.pkg_id
-            self._total_packets += 1
-            
-        # 数据
-        self._cache.put(data)
-        if not self._recording:
-            self.start()
-    
-    def trigger(self, data):
-        pass        
-    
-    def start(self):
-        self._recording = True
-        record_thread = Thread(target=self._consumer)
-        record_thread.start()
-        
-    def _consumer(self):
-        logger.debug(f"开始消费数据 _consumer: {self._cache.qsize()}")
-        while True:
-            if self._recording or (not self._cache.empty()):
-                data = self._cache.get()
-                if data is None:
-                    break
-                # 处理数据
-                self._points += len(data.eeg[0])
-                self._write_file(data.eeg)
-            else:
-                break
-            
-        self.close()
-        
-    def _write_file(self, data):
-        try:
-            if self._edf_writer is None:
-                self.initialize_edf()
-            
-            if (self._chunk.size == 0):
-                self._chunk = np.asarray(data)
-            else:                
-                self._chunk = np.hstack((self._chunk, data))
-                
-            if self._chunk.size >= self.sample_frequency * self.channels:                
-                self._write_chunk(self._chunk[:self.sample_frequency])
-                self._chunk = self._chunk[self.sample_frequency:]            
-            
-        except Exception as e:
-            logger.error(f"写入数据异常: {str(e)}")
-        
-    def close(self):
-        self._recording = False
-        if self._edf_writer:            
-            self._end_time = datetime.now().timestamp()
-            self._edf_writer.writeAnnotation(0, 1, "start recording ")
-            self._edf_writer.writeAnnotation(self._duration, 1, "recording end")
-            self._edf_writer.close()
-        
-        logger.info(f"文件: {self.file_name}完成记录, 总点数: {self._points}, 总时长: {self._duration}秒 丢包数: {self._lost_packets}/{self._total_packets + self._lost_packets}")
-        
-    
-        
-    def initialize_edf(self):
-        # 创建EDF+写入器
-        self._edf_writer = EdfWriter(
-            self.file_name,
-            self.channels,
-            file_type=self.file_type
-        )
-        
-        # 设置头信息
-        self._edf_writer.setPatientCode(self._patient_code)
-        self._edf_writer.setPatientName(self._patient_name)
-        self._edf_writer.setEquipment(self._device_type)
-        self._edf_writer.setStartdatetime(datetime.now())
-        
-        # 配置通道参数
-        signal_headers = []
-        for ch in range(self.channels):
-            signal_headers.append({
-                "label": f'channels {ch + 1}',
-                "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._edf_writer.setSignalHeaders(signal_headers)
-    
-    def _write_chunk(self, chunk):
-        logger.debug(f"写入数据: {chunk}")
-        # 转换数据类型为float64（pyedflib要求）
-        data_float64 = chunk.astype(np.float64)
-        # 写入时转置为(样本数, 通道数)格式
-        self._edf_writer.writeSamples(data_float64)
-        self._duration += 1
-
-