qlsdk2 0.1.6__tar.gz → 0.2.0__tar.gz

{qlsdk2-0.1.6 → qlsdk2-0.2.0}/PKG-INFO

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

{qlsdk2-0.1.6 → qlsdk2-0.2.0}/setup.py

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

{qlsdk2-0.1.6 → qlsdk2-0.2.0}/src/qlsdk/ar4m/ar4sdk.py

@@ -3,12 +3,14 @@ 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_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
 
 real_path = os.path.realpath(__file__)
 dll_path = f'{os.path.dirname(real_path)}/libs/libAr4SDK.dll'
@@ -89,10 +91,34 @@ _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_char_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
@@ -146,8 +172,10 @@ def _get_time():
     
 # ar4设备对象
 class AR4(object):
-    def __init__(self, box_mac, slot, hub_name):
+    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
@@ -166,13 +194,41 @@ class AR4(object):
         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._trigger_accept)
-        
-        # 消息订阅
-        self._consumers: dict[str, Queue] = {}
+        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):
@@ -187,6 +243,34 @@ class AR4(object):
         # 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()
@@ -194,7 +278,18 @@ class AR4(object):
                 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()
@@ -244,17 +339,6 @@ class AR4(object):
         self._acq_info["start_time"] = _get_time()
         
         if self._handle:
-            # 设置信号数据回调
-            try:
-                _dll.ar4_sdk_register_data_notify(self._handle, self._data_callback)
-            except Exception as e:
-                logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
-                
-            # 设置trigger数据回调
-            # try:
-            #     _dll.ar4_sdk_register_trigger_notify(self._handle, self._trigger_callback)
-            # except Exception as e:
-            #     logger.error(f"ar4 {self._box_mac} 停止采集异常: {str(e)}")
             # 启动采集
             try:
                 logger.debug(f"ar4 {self._box_mac} 启动采集: {self._handle}")
@@ -305,15 +389,22 @@ class AR4(object):
             logger.error(f"ar4 {self._box_mac} 获取采样开始时间异常: {str(e)}")
        
     # 订阅推送消息 
-    def subscribe(self, topic: str = None, q: Queue = Queue()):
+    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 topic in list(self._consumers.keys()):  
-            logger.warning(f"ar4 {self._box_mac} 订阅主题已存在: {topic}")
-            return topic, self._consumers[topic]
-        self._consumers[topic] = q
         
-        return topic, self._consumers[topic]
+        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):
         
@@ -322,21 +413,113 @@ class AR4(object):
             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._consumers) > 0:
+        if len(self._dig_subscriber) > 0 or len(self._phy_subscriber) > 0:
             packet = AR4Packet().transfer(data_ptr.contents)
-            for consumer in self._consumers.values():
+            
+            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}")
+    
+    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}, 
@@ -348,6 +531,20 @@ class AR4(object):
                 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}
+                ]
             """
             
 class Packet(object):
@@ -375,9 +572,12 @@ 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)]
+            # 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)]

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

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

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

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