qlsdk2 0.2.0a1__py3-none-any.whl → 0.3.0__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/persist/__init__.py

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

qlsdk/{ar4m/persist.py → persist/edf.py}

@@ -12,7 +12,10 @@ class EdfHandler(object):
         self.physical_min = physical_min
         self.digital_max = digital_max
         self.digital_min = digital_min
-        self.channels = None
+        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
@@ -70,7 +73,8 @@ class EdfHandler(object):
         if data:
             # 通道数
             if self._first_pkg_id is None:
-                self.channels = data.eeg_ch_count
+                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
                 
@@ -98,28 +102,32 @@ class EdfHandler(object):
         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:
+                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
-                # 处理数据
-                self._points += len(data.eeg[0])
-                self._write_file(data.eeg)
             else:
                 break
             
         self.close()
         
-    def _write_file(self, data):
+    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(data)
+                self._chunk = np.asarray(eeg_data)
             else:                
-                self._chunk = np.hstack((self._chunk, data))
+                self._chunk = np.hstack((self._chunk, eeg_data))
                 
-            if self._chunk.size >= self.sample_frequency * self.channels:                
+            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:]            
             
@@ -142,7 +150,7 @@ class EdfHandler(object):
         # 创建EDF+写入器
         self._edf_writer = EdfWriter(
             self.file_name,
-            self.channels,
+            self.eeg_channels,
             file_type=self.file_type
         )
         
@@ -154,7 +162,7 @@ class EdfHandler(object):
         
         # 配置通道参数
         signal_headers = []
-        for ch in range(self.channels):
+        for ch in range(self.eeg_channels):
             signal_headers.append({
                 "label": f'channels {ch + 1}',
                 "dimension": 'uV',

qlsdk/sdk/__init__.py

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