qlsdk2 0.2.0__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

qlsdk/__init__.py

@@ -1,9 +1,12 @@
 # __version__ = "0.1.1"
 
 # 暴露公共接口
-from .ar4m import AR4M, AR4, AR4Packet
+from .ar4m import AR4M
+from .ar4 import AR4
+from .x8 import X8
+from .x8m import X8M
 
-__all__ = ['AR4M', 'AR4', 'AR4Packet']
+__all__ = ['AR4M', 'AR4', 'AR4Packet', 'X8']
 
 # from importlib import import_module
 # from pathlib import Path

qlsdk/ar4/__init__.py

@@ -0,0 +1,128 @@
+from multiprocessing import Queue
+from typing import Literal
+from loguru import logger
+from qlsdk.sdk import LMDevice, LMPacket
+import numpy as np
+from qlsdk.persist import EdfHandler
+import time
+    
+# 设备对象
+class AR4(LMDevice):
+    def __init__(self, box_mac:str, is_persist:bool=True, storage_path:str=None):
+        # 是否持久化-保存为文件
+        self._is_persist = is_persist
+        self._storage_path = storage_path
+        self._edf_handler = None
+        
+        self._recording = False
+        self._record_start_time = None
+        
+        self._acq_info = {}
+        # 订阅者列表，数值为数字信号值
+        self._dig_subscriber: dict[str, Queue] = {}
+        # 订阅者列表，数值为物理信号值
+        self._phy_subscriber: dict[str, Queue] = {}
+        
+        super().__init__(box_mac)
+    
+    def set_storage_path(self, storage_path):
+        self._storage_path = storage_path
+
+    @property
+    def device_type(self):
+        return "AR4"
+    
+       
+    def eeg_accept(self, packet):        
+        if len(self._dig_subscriber) > 0 or len(self._phy_subscriber) > 0:            
+            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)
+            
+            if self._is_persist:
+                if self._edf_handler is None:
+                    self.start_record()
+                    self._recording = True
+                    self._record_start_time = packet.time_stamp
+                    logger.info(f"开始记录数据: {self.box_mac}")
+            
+                # 处理数据包
+                self._edf_handler.append(packet)
+    
+    def start_record(self):
+        if self._is_persist:
+            if self._edf_handler is None:
+                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)
+                self._edf_handler.set_storage_path(self._storage_path)
+                
+    def stop_record(self):
+        if self._edf_handler:
+            # 等待设备端数据传输完成
+            time.sleep(0.5)
+            # 添加结束标识
+            self._edf_handler.append(None)
+            self._edf_handler = None
+            self._recording = False
+            logger.info(f"停止记录数据: {self.box_mac}")
+
+    # 订阅推送消息 
+    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_{self.box_mac}"
+        
+        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 eeg2phy(self, digtal):
+        # 向量化计算（自动支持广播）
+        return super().eeg2phy(digtal)
+    
+    def acc2phy(self, digtal):
+        return super().eeg2phy(digtal)
+            
+class X8Packet(LMPacket):
+    def __init__(self, data: bytes):
+        super().__init__(data)
+        self._data = data
+        self._head = None
+        self._body = None
+        
+    @property
+    def head(self):
+        return self._head
+    
+    @property
+    def body(self):
+        return self._body
+    
+    def parse(self):
+        # 解析数据包头部和数据体
+        if len(self._data) < 4:
+            logger.error(f"数据包长度不足: {len(self._data)}")
+            return False
+        
+        # 解析头部和数据体
+        self._head = self._data[:4]
+        self._body = self._data[4:]
+        
+        return True

qlsdk/ar4m/__init__.py

@@ -1,50 +1,21 @@
-__path__ = __import__("pkgutil").extend_path(__path__, __name__)
-
-from .ar4sdk import AR4SDK, AR4, Packet, AR4Packet
-
-
-from time import sleep, time
-from threading import Lock, Timer
+from qlsdk.sdk import Hub
+from qlsdk.ar4 import AR4
 from loguru import logger
 
-class AR4M(object):
+
+class AR4M(Hub):
     def __init__(self):
-        self._lock = Lock()
-        self._search_timer = None 
-        self._search_running = False
+        super().__init__()
         self._devices: dict[str, AR4] = {}
+        self._search_running = False
+        self._search_timer = None
     
-    @property
-    def devices(self):
-        return self._devices
-    def search(self):
-        if not self._search_running:
-            self._search_running = True
-            self._search()
-        
-    def _search(self):
-        if self._search_running:
-
-            self._search_timer = Timer(2, self._search_ar4)
-            self._search_timer.daemon = True
-            self._search_timer.start()
-        
-        
-    def _search_ar4(self):
-        try:                        
-            devices = AR4SDK.enum_devices()
-            # logger.debug(f"_search_ar4 devices size: {len(devices)}")
-            for dev in devices:
-                # logger.debug(f"slot: {dev.slot}, mac: {dev.mac}-{hex(dev.mac)}, hub_name: {dev.hub_name.str}")
-                if dev.mac in list(self._devices.keys()):
-                    ar4 = self._devices[dev.mac]
-                    ar4.update_info()
-                else:
-                    ar4 = AR4(hex(dev.mac), dev.slot, dev.hub_name.str.decode("utf-8"))
-                    if ar4.init():
-                        self._devices[dev.mac] = ar4
-                        logger.info(f"add device mac: {ar4.box_mac} slot: {ar4.slot} hub_name: {ar4.hub_name}")
-        except Exception as e:
-            logger.error(f"_search_ar4 异常: {str(e)}")
-        finally:
-            self._search()
+    def add_device(self, mac: str):
+        if mac in list(self._devices.keys()):
+            self._devices[mac].update_info()
+            logger.debug(f"update x8 device mac: {mac}")
+        else:
+            dev = AR4(mac)
+            if dev.connected:
+                self._devices[mac] = dev
+                logger.info(f"add x8 device mac: {dev}")

qlsdk/ar4m/ar4sdk.py

@@ -11,6 +11,7 @@ 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'
@@ -162,16 +163,13 @@ class AR4SDK:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
-  
 
 # 读取系统当前时间(ms)
 def _get_time():
     cur_time = int(round(time()) * 1000)
-    logger.debug(f"_get_time is {cur_time}")
     return cur_time  
-    
-# ar4设备对象
-class AR4(object):
+
+class LMDevice(object):
     def __init__(self, box_mac:str, slot:int, hub_name:str):
         # 设备句柄
         self._handle = None
@@ -424,8 +422,12 @@ class AR4(object):
                 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)
         
@@ -545,6 +547,420 @@ class AR4(object):
                 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):
@@ -572,11 +988,6 @@ class AR4Packet(Packet):
         self.acc_count = data.acc_count
         # 读eeg数据
         if self.eeg_ch_count and self.eeg_count:
-            # self.eeg = [[] for _ in range(self.eeg_ch_count)]
-            # for i in range(self.eeg_ch_count):
-                # self.eeg[i] = [data.eeg[j + (i * self.eeg_count)] for j in range(self.eeg_count)]
-            # tmp = data.eeg[:self.eeg_ch_count * self.eeg_count]
-            # logger.info(tmp)
             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: