qlsdk2 0.2.0__tar.gz → 0.3.0a1__tar.gz

{qlsdk2-0.2.0 → qlsdk2-0.3.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qlsdk2
-Version: 0.2.0
+Version: 0.3.0a1
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun
@@ -12,6 +12,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: loguru>=0.6.0
 Requires-Dist: numpy>=1.23.5
+Requires-Dist: pyedflib>=0.1.40
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: twine>=3.0; extra == "dev"

{qlsdk2-0.2.0 → qlsdk2-0.3.0a1}/setup.py

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

{qlsdk2-0.2.0 → qlsdk2-0.3.0a1}/src/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

qlsdk2-0.3.0a1/src/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

qlsdk2-0.3.0a1/src/qlsdk/ar4m/__init__.py

@@ -0,0 +1,21 @@
+from qlsdk.sdk import Hub
+from qlsdk.ar4 import AR4
+from loguru import logger
+
+
+class AR4M(Hub):
+    def __init__(self):
+        super().__init__()
+        self._devices: dict[str, AR4] = {}
+        self._search_running = False
+        self._search_timer = None
+    
+    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}")

qlsdk2-0.3.0a1/src/qlsdk/persist/__init__.py

@@ -0,0 +1 @@
+from .edf import EdfHandler

qlsdk2-0.3.0a1/src/qlsdk/persist/edf.py

@@ -0,0 +1,186 @@
+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.eeg_channels = None
+        self.eeg_sample_rate = 500
+        self.acc_channels = None
+        self.acc_sample_rate = 50
+        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.eeg_channels = data.eeg_ch_count
+                self.acc_channels = data.acc_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()):
+                try:
+                    data = self._cache.get(timeout=10)
+                    if data is None:
+                        break
+                    # 处理数据
+                    self._points += len(data.eeg[0])
+                    self._write_file(data.eeg, data.acc)
+                except Exception as e:
+                    logger.error("数据队列为空，超时(10s)结束")
+                    break
+            else:
+                break
+            
+        self.close()
+        
+    def _write_file(self, eeg_data, acc_data):
+        try:
+            if self._edf_writer is None:
+                self.initialize_edf()
+            
+            if (self._chunk.size == 0):
+                self._chunk = np.asarray(eeg_data)
+            else:                
+                self._chunk = np.hstack((self._chunk, eeg_data))
+                
+            if self._chunk.size >= self.eeg_sample_rate * self.eeg_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.eeg_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.eeg_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
+
+    

qlsdk2-0.3.0a1/src/qlsdk/sdk/__init__.py

@@ -0,0 +1,2 @@
+from .ar4sdk import LMDevice, LMPacket, AR4SDK
+from .hub import Hub

{qlsdk2-0.2.0/src/qlsdk/ar4m → qlsdk2-0.3.0a1/src/qlsdk/sdk}/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,17 +163,64 @@ class AR4SDK:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
-  
 
+
+# 枚举后才能连接上
+AR4SDK.enum_devices()
 # 读取系统当前时间(ms)
 def _get_time():
     cur_time = int(round(time()) * 1000)
-    logger.debug(f"_get_time is {cur_time}")
     return cur_time  
+       
+class Packet(object):
+    pass
+            
+class LMPacket(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
     
-# ar4设备对象
-class AR4(object):
-    def __init__(self, box_mac:str, slot:int, hub_name:str):
+    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}
+        """
+
+class LMDevice(object):
+    def __init__(self, box_mac:str):
         # 设备句柄
         self._handle = None
         # 设备基本信息
@@ -188,8 +236,8 @@ class AR4(object):
         self._head_conn_state = None
         self._head_soc = None
         self._net_state = None
-        self._hub_name = hub_name
-        self._slot = slot
+        # self._hub_name = hub_name
+        # self._slot = slot
         self._connected = False
         self._conn_time = None
         self._last_time = None
@@ -214,11 +262,9 @@ class AR4(object):
         self._acc_phy_range = None
         self._acc_dig_range = None
         
+        self._sample_frequency = 500
+        
         self._acq_info = {}
-        # 订阅者列表，数值为数字信号值
-        self._dig_subscriber: dict[str, Queue] = {}
-        # 订阅者列表，数值为物理信号值
-        self._phy_subscriber: dict[str, Queue] = {}
         
         # 回调函数
         self._data_callback = FuncAr4DataNotify(self._wrap_data_accept())        
@@ -230,6 +276,16 @@ class AR4(object):
         self._start_record_notify_callback = FuncAr4RecorderConnected(self._wrap_start_record_notify())
         self._stop_record_notify_callback = FuncAr4RecorderDisconnected(self._wrap_stop_record_notify())
         
+        self.init()
+        
+    @property
+    def connected(self):
+        return self._connected
+    
+    @property
+    def sample_frequency(self):
+        return self._sample_frequency
+    
     @property
     def box_mac(self):
         return self._box_mac
@@ -239,47 +295,185 @@ class AR4(object):
     @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()
+    
+    @property
+    def eeg_phy_max(self):
+        return self._eeg_phy_max
+    
+    @property
+    def eeg_phy_min(self):
+        return self._eeg_phy_min
+    
+    @property
+    def eeg_dig_max(self):
+        return self._eeg_dig_max
+    
+    @property
+    def eeg_dig_min(self):  
+        return self._eeg_dig_min
+    
+    @property
+    def acc_phy_max(self):
+        return self._acc_phy_max
+    
+    @property
+    def acc_phy_min(self):  
+        return self._acc_phy_min
+    
+    @property
+    def acc_dig_max(self):
+        return self._acc_dig_max
+    
+    @property
+    def acc_dig_min(self):  
+        return self._acc_dig_min
+    
+    @property
+    def eeg_phy_unit(self):
+        return self._eeg_phy_unit
+    
+    @property
+    def acc_phy_unit(self):
+        return self._acc_phy_unit
+    
+    @property
+    def eeg_phy_range(self):
+        return self._eeg_phy_range
+    
+    @property
+    def eeg_dig_range(self):
+        return self._eeg_dig_range
+    
+    @property
+    def acc_phy_range(self):
+        return self._acc_phy_range
+    
+    @property
+    def acc_dig_range(self):
+        return self._acc_dig_range
+    
+    def init(self):        
+        if self.connect():
+            self.get_sample_rate()
             ## 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.get_eeg_phy_max()
+            self.get_eeg_phy_min()
+            self.get_eeg_phy_unit()
+            self.get_eeg_digital_max()
+            self.get_eeg_digital_min()
             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.get_acc_phy_max()
+            self.get_acc_phy_min()
+            self.get_acc_phy_unit()
+            self.get_acc_digital_max()
+            self.get_acc_digital_min()
             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
+            return True
+        else:
+            logger.error(f"设备[{self._box_mac}]连接失败")
+            return False
+    
+    def get_eeg_phy_max(self):
+        if self._handle:
+            try:
+                self._eeg_phy_max = _dll.ar4_sdk_get_eeg_phy_max(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取eeg物理最大值异常: {str(e)}")
+        
+        return self._eeg_phy_max
+    
+    def get_eeg_phy_min(self):
+        if self._handle:
+            try:
+                self._eeg_phy_min = _dll.ar4_sdk_get_eeg_phy_min(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取eeg物理最小值异常: {str(e)}")
+        
+        return self._eeg_phy_min
+
+    def get_eeg_phy_unit(self):
+        if self._handle:
+            try:
+                eeg_unit = _dll.ar4_sdk_get_eeg_phy_unit(self._handle)
+                if eeg_unit:
+                        self._eeg_phy_unit = eeg_unit.decode("utf-8")
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取eeg物理单位异常: {str(e)}")
+        
+        return self._eeg_phy_unit
+    
+    def get_eeg_digital_max(self):
+        if self._handle:
+            try:
+                self._eeg_dig_max = _dll.ar4_sdk_get_eeg_digtal_max(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取eeg数字最大值异常: {str(e)}")
+        
+        return self._eeg_dig_max
+    
+    def get_eeg_digital_min(self):
+        if self._handle:
+            try:
+                self._eeg_dig_min = _dll.ar4_sdk_get_eeg_digtal_min(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取eeg数字最小值异常: {str(e)}")
+        
+        return self._eeg_dig_min
+    
+    
+    def get_acc_phy_max(self):
+        if self._handle:
+            try:
+                self._acc_phy_max = _dll.ar4_sdk_get_acc_phy_max(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取acc物理最大值异常: {str(e)}")
+        
+        return self._acc_phy_max
+    
+    def get_acc_phy_min(self):
+        if self._handle:
+            try:
+                self._acc_phy_min = _dll.ar4_sdk_get_acc_phy_min(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取acc物理最小值异常: {str(e)}")
+        
+        return self._eeg_phy_min
+
+    def get_acc_phy_unit(self):
+        if self._handle:
+            try:
+                acc_unit = _dll.ar4_sdk_get_acc_phy_unit(self._handle)
+                if acc_unit:
+                        self._acc_phy_unit = acc_unit.decode("utf-8")
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取acc物理单位异常: {str(e)}")
+        
+        return self._acc_phy_unit
+    
+    def get_acc_digital_max(self):
+        if self._handle:
+            try:
+                self._acc_dig_max = _dll.ar4_sdk_get_acc_digtal_max(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取acc数字最大值异常: {str(e)}")
+        
+        return self._acc_dig_max
+    
+    def get_acc_digital_min(self):
+        if self._handle:
+            try:
+                self._acc_dig_min = _dll.ar4_sdk_get_acc_digtal_min(self._handle)
+            except Exception as e:
+                logger.error(f"设备[{self._box_mac}]获取acc数字最小值异常: {str(e)}")
+        
+        return self._acc_dig_min
     
     def _register_callback(self):
         try:
@@ -289,7 +483,7 @@ class AR4(object):
             _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)}")
+            logger.error(f"设备[{self._box_mac}]回调函数注册异常: {str(e)}")
 
     def update_info(self):
         self._last_time = _get_time()
@@ -297,17 +491,28 @@ class AR4(object):
     # 设备连接
     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
+        if not self._box_mac:
+            raise Exception("设备MAC地址不能为空")
+        
+        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._connected = self._handle is not None
+            if self._handle:
+                self._connected = True
+                self._handle = c_void_p(self._handle)     
+                self._conn_time = _get_time()
+                self.get_box_name()
+                self.get_head_mac()
+                self.get_record_conn_state()
+                self._last_time = _get_time()
+            else:
+                raise Exception(f"设备 {self._box_mac} 连接失败: {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._connected
     
     # 读取盒子名称
     def get_box_name(self):
@@ -333,23 +538,27 @@ class AR4(object):
 
     # 数据采集启动
     def start_acquisition(self):
-        logger.info(f"ar4 {self._box_mac} 启动数据采集...")
-        """启动数据采集"""
+        logger.info(f"device {self._box_mac} 启动数据采集...")
+        if not self._handle:
+            self.init()
         
         self._acq_info["start_time"] = _get_time()
         
         if self._handle:
             # 启动采集
             try:
-                logger.debug(f"ar4 {self._box_mac} 启动采集: {self._handle}")
+                logger.debug(f"device {self._box_mac} 启动采集: {self._handle}")
                 ret = _dll.ar4_sdk_start_acq(self._handle)
-                logger.debug(f"ar4 {self._box_mac} 启动采集结果: {ret}")
-                    
+                if ret == 0:
+                    logger.info(f"device {self._box_mac} 启动数据采集成功")
+                    self.start_record()
+                else:
+                    logger.error(f"device {self._box_mac} 启动数据采集失败, ret: {ret}")
                 return ret == 0
             except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
+                logger.error(f"device {self._box_mac} 停止采集异常: {str(e)}")
         else:
-            logger.info(f"ar4 {self._box_mac} 启动数据采集失败， 设备未连接")
+            logger.info(f"device {self._box_mac} 启动数据采集失败， 设备未连接")
             return False
 
     def stop_acquisition(self):
@@ -360,11 +569,23 @@ class AR4(object):
             except Exception as e:
                 logger.error(f"ar4 {self._box_mac} 获取开始采集时间异常: {str(e)}")
             try:
-                return _dll.ar4_sdk_stop_acq(self._handle) == 0
+                ret = _dll.ar4_sdk_stop_acq(self._handle)
+                if ret == 0:
+                    logger.info(f"device {self._box_mac} 停止采集成功")
+                    self.stop_record()
+                else:
+                    logger.error(f"device {self._box_mac} 停止采集失败, ret: {ret}")
+                    
+                return ret == 0
             except Exception as e:
                 logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
         else:
             return False
+        
+    def start_record(self):
+        pass
+    def stop_record(self):
+        pass
 
     def disconnect(self):
         """断开连接"""
@@ -374,7 +595,9 @@ class AR4(object):
     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')}")
+            logger.debug(f"ar4 {self._box_mac} 获取采样率: {ret}")
+            if ret > 1:
+                self._sample_frequency = ret
         except Exception as e:
             logger.error(f"ar4 {self._box_mac} 获取采样率异常: {str(e)}")
             
@@ -387,24 +610,6 @@ class AR4(object):
             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):
         
@@ -414,23 +619,10 @@ class AR4(object):
             
         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:
-                packet.eeg = self.eeg2phy(np.array(packet.eeg))
-                packet.acc = self.acc2phy(np.array(packet.acc))
-                for consumer2 in self._phy_subscriber.values():
-                    consumer2.put(packet)
-        
-            # logger.debug(f"EEG数据: {packet}")
+        self.eeg_accept(LMPacket().transfer(data_ptr.contents))
     
+    def eeg_accept(self, packet: LMPacket):  
+        pass
     def eeg2phy(self, digtal):
         # 向量化计算（自动支持广播）
         return ((digtal - self._eeg_dig_min) / self._eeg_dig_range) * self._eeg_phy_range + self._eeg_phy_min
@@ -506,8 +698,7 @@ class AR4(object):
         logger.info(f"_start_record_notify 被调用 handle: {handle}")        
         self._recording = True
         self._record_start_time = time()
-        logger.info(self)
-        
+        logger.info(self)        
         
     def _wrap_stop_record_notify(self):
         @FuncAr4RecorderDisconnected
@@ -545,56 +736,7 @@ 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}
             """
-            
-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 = [[] 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:
-            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}
-        """
+     

qlsdk2-0.3.0a1/src/qlsdk/sdk/hub.py

@@ -0,0 +1,51 @@
+from qlsdk.sdk.ar4sdk import AR4SDK, LMDevice
+
+
+from time import sleep, time
+from threading import Lock, Timer
+from loguru import logger
+
+class Hub(object):
+    def __init__(self):
+        self._lock = Lock()
+        self._search_timer = None 
+        self._search_running = False
+        self._devices: dict[str, LMDevice] = {}
+    
+    @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_device)
+            self._search_timer.daemon = True
+            self._search_timer.start()
+        
+        
+    def _search_device(self):
+        try:                        
+            devices = AR4SDK.enum_devices()
+            # logger.debug(f"_search_ar4 devices size: {len(devices)}")
+            for dev in devices:
+                self.add_device(hex(dev.mac))
+        except Exception as e:
+            logger.error(f"_search_device 异常: {str(e)}")
+        finally:
+            self._search()
+            
+    def add_device(self, mac: str):
+        if mac in list(self._devices.keys()):
+            self._devices[mac].update_info()
+            logger.info(f"update device mac: {mac}")
+        else:
+            dev = LMDevice(mac)
+            if dev.init():
+                self._devices[mac] = dev
+                logger.info(f"add device mac: {dev}")

qlsdk2-0.3.0a1/src/qlsdk/x8/__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 X8(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 "x8"
+    
+       
+    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

qlsdk2-0.3.0a1/src/qlsdk/x8m/__init__.py

@@ -0,0 +1,21 @@
+from qlsdk.sdk import Hub
+from qlsdk.x8 import X8
+from loguru import logger
+
+
+class X8M(Hub):
+    def __init__(self):
+        super().__init__()
+        self._devices: dict[str, X8] = {}
+        self._search_running = False
+        self._search_timer = None
+    
+    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 = X8(mac)
+            if dev.connected:
+                self._devices[mac] = dev
+                logger.info(f"add x8 device mac: {dev}")

{qlsdk2-0.2.0 → qlsdk2-0.3.0a1}/src/qlsdk2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qlsdk2
-Version: 0.2.0
+Version: 0.3.0a1
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun
@@ -12,6 +12,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: loguru>=0.6.0
 Requires-Dist: numpy>=1.23.5
+Requires-Dist: pyedflib>=0.1.40
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: twine>=3.0; extra == "dev"

{qlsdk2-0.2.0 → qlsdk2-0.3.0a1}/src/qlsdk2.egg-info/SOURCES.txt

@@ -7,8 +7,13 @@ src/qlsdk2.egg-info/SOURCES.txt
 src/qlsdk2.egg-info/dependency_links.txt
 src/qlsdk2.egg-info/requires.txt
 src/qlsdk2.egg-info/top_level.txt
+src/qlsdk/ar4/__init__.py
 src/qlsdk/ar4m/__init__.py
-src/qlsdk/ar4m/ar4sdk.py
-src/qlsdk/ar4m/libs/libAr4SDK.dll
-src/qlsdk/ar4m/libs/libwinpthread-1.dll
+src/qlsdk/persist/__init__.py
+src/qlsdk/persist/edf.py
+src/qlsdk/sdk/__init__.py
+src/qlsdk/sdk/ar4sdk.py
+src/qlsdk/sdk/hub.py
+src/qlsdk/x8/__init__.py
+src/qlsdk/x8m/__init__.py
 test/test_ar4m.py

{qlsdk2-0.2.0 → qlsdk2-0.3.0a1}/src/qlsdk2.egg-info/requires.txt

@@ -1,5 +1,6 @@
 loguru>=0.6.0
 numpy>=1.23.5
+pyedflib>=0.1.40
 
 [dev]
 pytest>=6.0

qlsdk2-0.2.0/src/qlsdk/ar4m/__init__.py

@@ -1,50 +0,0 @@
-__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 loguru import logger
-
-class AR4M(object):
-    def __init__(self):
-        self._lock = Lock()
-        self._search_timer = None 
-        self._search_running = False
-        self._devices: dict[str, AR4] = {}
-    
-    @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()