qlsdk2 0.4.0a2__py3-none-any.whl → 0.4.1__py3-none-any.whl

qlsdk/ar4/__init__.py

@@ -39,12 +39,12 @@ class AR4(LMDevice):
                 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}")
+                logger.debug(f"dig data eeg: {packet.eeg}")
+                logger.debug(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}")
+                logger.debug(f"phy data eeg: {packet.eeg}")
+                logger.debug(f"phy data acc: {packet.acc}")
                 for consumer2 in self._phy_subscriber.values():
                     consumer2.put(packet)
             
@@ -74,7 +74,11 @@ class AR4(LMDevice):
             self._edf_handler = None
             self._recording = False
             logger.info(f"停止记录数据: {self.box_mac}")
-
+            
+    def trigger(self, desc):
+        if self._edf_handler:
+            self._edf_handler.trigger(desc)
+            
     # 订阅推送消息 
     def subscribe(self, topic: str = None, q: Queue = Queue(), value_type: Literal['phy', 'dig'] = 'phy') -> tuple[str, Queue]:
         if topic is None:

qlsdk/core/__init__.py

@@ -1,4 +1,5 @@
 from qlsdk.core.crc import *
 from qlsdk.core.message import *
 from qlsdk.core.local import *
-from qlsdk.core.utils import *
+from qlsdk.core.utils import *
+from qlsdk.core.entity import *

qlsdk/core/device.py

@@ -4,9 +4,18 @@ class BaseDevice(object):
     def __init__(self, socket = None):
         self.socket = socket
         self.device_name = None
-        self.device_type = None
+        self._device_type = None
         self.device_id = None
         
+        
+    @property
+    def device_type(self) -> int:
+        return self._device_type
+    
+    @device_type.setter
+    def device_type(self, value: int):
+        self._device_type = value
+        
     @property
     def acq_channels(self) :
         return None

qlsdk/core/entity/__init__.py

@@ -46,7 +46,7 @@ class RscPacket(object):
             for i in range(ch_num)
         ]
                 
-        logger.trace(self)
+        # logger.trace(self)
         return self
         
     def __str__(self):

qlsdk/core/message/command.py

@@ -1,7 +1,10 @@
 import abc
+import numpy as np
+from time import time_ns
 from typing import Dict, Type
-from enum import Enum
 from loguru import logger
+
+
 from qlsdk.core.crc import crc16
 from qlsdk.core.device import BaseDevice
 from qlsdk.core.entity import RscPacket, ImpedancePacket
@@ -26,6 +29,10 @@ class DeviceCommand(abc.ABC):
     @abc.abstractmethod
     def cmd_code(self) -> int:
         pass
+    @property
+    @abc.abstractmethod
+    def cmd_desc(self) -> str:
+        pass
     
     @staticmethod
     def checksum(data: bytes) -> bytes:
@@ -59,6 +66,13 @@ class DeviceCommand(abc.ABC):
         # 解析消息体
         body = payload[self.HEADER_LEN:-2]   
     
+    def parse_body(self, body: bytes):
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        logger.info(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
+        
+    
 
 class CommandFactory:
     """Registry for command implementations"""
@@ -70,15 +84,16 @@ class CommandFactory:
     
     @classmethod
     def create_command(cls, code: int) -> Type[DeviceCommand]:
-        logger.debug(f"Creating command for code: {hex(code)}")
+        logger.trace(f"Creating command for code: {hex(code)}")
         if code not in cls._commands:
-            logger.warning(f"Unsupported command code: {hex(code)}")
+            logger.warning(f"不支持的设备指令: {hex(code)}")
             return cls._commands[DefaultCommand.cmd_code]
         return cls._commands[code]
 
 # =============================================================================
 class DefaultCommand(DeviceCommand):    
     cmd_code = 0x00   
+    cmd_desc = "未定义"
         
     def parse_body(self, body: bytes):
         # Response parsing example: 2 bytes version + 4 bytes serial
@@ -86,9 +101,9 @@ class DefaultCommand(DeviceCommand):
     
 class GetDeviceInfoCommand(DeviceCommand):
     cmd_code = 0x17
+    cmd_desc = "设备信息"
     
     def parse_body(self, body: bytes):
-        logger.info(f"Received GetDeviceInfoCommand body len: {len(body)}")
         # time - 8B
         self.device.connect_time = int.from_bytes(body[0:8], 'little')
         self.device.current_time = self.device.connect_time
@@ -108,10 +123,13 @@ class GetDeviceInfoCommand(DeviceCommand):
         flag = int.from_bytes(body[41:45], 'little')
         logger.debug(f"Received device info: {result}, {flag}, {self.device}")
         
+        # 创建设备对象
+        
 
 # 握手
 class HandshakeCommand(DeviceCommand):
     cmd_code = 0x01
+    cmd_desc = "握手"
     
     def parse_body(self, body: bytes):
         logger.info(f"Received handshake response: {body.hex()}")
@@ -119,8 +137,8 @@ class HandshakeCommand(DeviceCommand):
 # 查询电量
 class QueryBatteryCommand(DeviceCommand):
     cmd_code = 0x16
+    cmd_desc = "电量信息"
     def parse_body(self, body: bytes):
-        logger.info(f"Received QueryBatteryCommand body len: {len(body)}")
         # time - 8b
         self.device.current_time = int.from_bytes(body[0:8], 'little')
         # result - 1b
@@ -135,12 +153,15 @@ class QueryBatteryCommand(DeviceCommand):
             self.device.battery_total = body[12]
             # state - 1b
             # state = body[13]
+            logger.debug(f"电量更新: {self.device}")
         else:
             logger.warning(f"QueryBatteryCommand message received but result is failed.")
 
 # 设置采集参数
 class SetAcquisitionParamCommand(DeviceCommand):
     cmd_code = 0x451
+    cmd_desc = "设置信号采集参数"
+    
     def pack_body(self):
         body = to_bytes(self.device.acq_channels) 
         body += self.device.sample_range.to_bytes(4, byteorder='little')
@@ -150,76 +171,56 @@ class SetAcquisitionParamCommand(DeviceCommand):
         body += bytes.fromhex('00')        
 
         return body
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetAcquisitionParam response: {body.hex()}")
         
 # 启动采集
 class StartAcquisitionCommand(DeviceCommand):
     cmd_code = 0x452
+    cmd_desc = "启动信号采集"
     
     def pack_body(self):
         return bytes.fromhex('0000')
-    def parse_body(self, body: bytes):
-        logger.info(f"Received acquisition start response: {body.hex()}")
 
 # 停止采集
 class StopAcquisitionCommand(DeviceCommand):
     cmd_code = 0x453
+    cmd_desc = "停止信号采集"
     
     def pack_body(self):
         return b''
-    def parse_body(self, body: bytes):
-        logger.info(f"Received acquisition stop response: {body.hex()}")
+
+        
 # 设置阻抗采集参数
 class SetImpedanceParamCommand(DeviceCommand):
     cmd_code = 0x411
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetImpedanceParamCommand response: {body.hex()}")
-# 启动采集
+    cmd_desc = "设置阻抗测量参数"
+        
+# 启动阻抗测量
 class StartImpedanceCommand(DeviceCommand):
     cmd_code = 0x412
+    cmd_desc = "启动阻抗测量"
     def pack_body(self):
         body = bytes.fromhex('0000')
         body += to_bytes(self.device.acq_channels)
         body += bytes.fromhex('0000000000000000') # 8字节占位符
         return body
         
-    def parse_body(self, body: bytes):
-        logger.info(f"Received StartImpedanceCommand response: {body.hex()}")
 
-# 停止采集
+# 停止阻抗测量
 class StopImpedanceCommand(DeviceCommand):
     cmd_code = 0x413
+    cmd_desc = "停止阻抗测量"
     
     def pack_body(self):
         return b''
-
-    def parse_body(self, body: bytes):
-        logger.info(f"Received StopImpedanceCommand response: {body.hex()}")
-    
-# 设置采集参数
-class SetStimulationParamCommand(DeviceCommand):
-    cmd_code = 0x451
-    def pack_body(self):
-        body = to_bytes(self.device.acq_channels) 
-        body += self.device.sample_range.to_bytes(4, byteorder='little')
-        body += self.device.sample_rate.to_bytes(4, byteorder='little')
-        body += self.device.sample_num.to_bytes(4, byteorder='little')
-        body += self.device.resolution.to_bytes(1, byteorder='little')
-        body += bytes.fromhex('00')        
-
-        return body
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetAcquisitionParam response: {body.hex()}")
             
-# 启动采集
+# 启动刺激
 class StartStimulationCommand(DeviceCommand):
     cmd_code = 0x48C
+    cmd_desc = "启动刺激"
     def pack_body(self):
         return self.device.stim_paradigm.to_bytes()
         # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
     def parse_body(self, body: bytes):
-        logger.info(f"Received stimulation start response: {body.hex()}")
         # time - 8B
         time = int.from_bytes(body[0:8], 'little')
         # result - 1B
@@ -227,28 +228,58 @@ class StartStimulationCommand(DeviceCommand):
         # error_channel - 8B
         # error_channel= int.from_bytes(body[9:17], 'big')
         channels = to_channels(body[9:17])
-        logger.warning(f"通道 {channels} 刺激驱动不足")
+        logger.success(f"通道 {channels} 刺激开始")
+        self.device.trigger(f"通道 {channels} 刺激开始")
         # error_type - 1B
         error_type = body[17]
 
-# 停止采集
+# 停止刺激
 class StopStimulationCommand(DeviceCommand):
     cmd_code = 0x488
-    
+    cmd_desc = "停止刺激"
+     
+# 启动刺激
+class StopStimulationNotifyCommand(DeviceCommand):
+    cmd_code = 0x48D
+    cmd_desc = "停止刺激通知"
+    def pack_body(self):
+        return self.device.stim_paradigm.to_bytes()
+        # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
     def parse_body(self, body: bytes):
-        logger.info(f"Received stimulation stop response: {body.hex()}")
-        
-# 停止采集
+        # time - 8B
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        # error_channel - 8B
+        # error_channel= int.from_bytes(body[9:17], 'big')
+        channels = to_channels(body[9:17])
+        logger.success(f"通道 {channels} 刺激结束")
+        self.device.trigger(f"通道 {channels} 刺激结束", time)
+        # error_type - 1B
+        error_type = body[17]   
+# 刺激信息
 class StimulationInfoCommand(DeviceCommand):
     cmd_code = 0x48e
+    cmd_desc = "刺激告警信息"
     
     def parse_body(self, body: bytes):
-        logger.info(f"Received stimulation info response: {body.hex()}")
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        # error_channel - 8B
+        channels = to_channels(body[9:17])
+        # 保留位-8B
+        # error_type - 1B
+        err_type = body[17]
+        # 特征位-4B
+        # errType  = int.from_bytes(body[25:29], 'little')
+        logger.warning(f"刺激告警信息[{err_type}]，通道 {channels} 刺激驱动不足")
         
 
 # 阻抗数据
 class ImpedanceDataCommand(DeviceCommand):
     cmd_code = 0x415
+    cmd_desc = "阻抗数据"
     
     def parse_body(self, body: bytes):
         logger.info(f"Received impedance data: {body.hex()}")
@@ -257,24 +288,33 @@ class ImpedanceDataCommand(DeviceCommand):
 # 信号数据
 class SignalDataCommand(DeviceCommand):
     cmd_code = 0x455
+    cmd_desc = "信号数据"
     
     def unpack(self, payload):
         return super().unpack(payload)
     
-    def parse_body(self, body: bytes):        
-        # logger.info(f"Received signal data: {len(body)}字节, the subscribe is {self.device.signal_consumers}")
-        if len(self.device.signal_consumers) > 0:
-            # 解析数据包
-            rsc = RscPacket()
-            rsc.transfer(body)
+    def parse_body(self, body: bytes):     
+        # 解析数据包
+        packet = RscPacket()
+        packet.transfer(body)  
+        
+        # 文件写入到edf
+        if self.device.edf_handler:
+            self.device.edf_handler.write(packet)
+                        
+        if len(self.device.signal_consumers) > 0 :
+            # 信号数字值转物理值
+            packet.eeg = self.device.eeg2phy(np.array(packet.eeg))
+            
             # 发送数据包到订阅者
             for q in list(self.device.signal_consumers.values()):
-                q.put(rsc)
+                q.put(packet)
+                
+            
 
 # =============================================================================
-# Command Registration
+# 指令实现类注册到指令工厂
 # =============================================================================
-
 CommandFactory.register_command(DefaultCommand.cmd_code, DefaultCommand)
 CommandFactory.register_command(GetDeviceInfoCommand.cmd_code, GetDeviceInfoCommand)
 CommandFactory.register_command(HandshakeCommand.cmd_code, HandshakeCommand)

qlsdk/core/network/__init__.py

@@ -0,0 +1,34 @@
+import psutil
+import socket
+
+def get_active_interfaces():
+    interfaces = {}
+    # 获取所有接口地址信息
+    all_addrs = psutil.net_if_addrs()
+    # 获取接口状态（是否处于UP状态）
+    stats = psutil.net_if_stats()
+    
+    for name, addrs in all_addrs.items():
+        # 检查接口是否启用
+        if stats[name].isup:
+            ips = []
+            for addr in addrs:
+                # 提取IPv4和IPv6地址
+                if addr.family == socket.AF_INET:
+                    ips.append(f"IPv4: {addr.address}")
+                elif addr.family == socket.AF_INET6:
+                    ips.append(f"IPv6: {addr.address}")
+            # 过滤无IP的接口（可选）
+            if ips:
+                interfaces[name] = {
+                    "status": "UP",
+                    "IPs": ips
+                }
+    return interfaces
+
+# 调用并打印结果
+active_ifs = get_active_interfaces()
+for iface, info in active_ifs.items():
+    print(f"接口: {iface}")
+    print(f"状态: {info['status']}")
+    print(f"IP地址: {info['IPs']}\n")

qlsdk/core/network/monitor.py

@@ -0,0 +1,55 @@
+from threading import Thread
+import psutil
+import time
+
+def get_active_ipv4():
+    ips = []
+    # 获取所有接口地址信息
+    all_addrs = psutil.net_if_addrs()
+    # 获取接口状态（是否处于UP状态）
+    stats = psutil.net_if_stats()
+    
+    for name, addrs in all_addrs.items():
+        # 检查接口是否启用
+        if stats[name].isup:
+            for addr in addrs:
+                # 提取IPv4地址
+                if addr.family == socket.AF_INET:
+                    ips.append(addr.address)
+    return ips
+def monitor_up_interfaces(interval=2, callback=None):
+    prev_status = {iface: psutil.net_if_stats()[iface].isup 
+                  for iface in psutil.net_if_stats()}
+    
+    while True:
+        current_stats = psutil.net_if_stats()
+        for iface, stats in current_stats.items():
+            current_up = stats.isup
+            # 检测状态变化
+            if current_up != prev_status.get(iface, None):
+                if current_up:
+                    print(f"[UP] 接口 {iface} 激活")
+                    if callback: callback(iface, "UP")
+                else:
+                    print(f"[DOWN] 接口 {iface} 断开")
+                    if callback: callback(iface, "DOWN")
+                prev_status[iface] = current_up
+        time.sleep(interval)
+
+# 自定义回调函数示例
+def notify(iface, status):
+    if status == "UP":
+        print(f"接口 {iface} 已激活")
+
+# 启动监听
+# monitor_up_interfaces(callback=notify)
+
+monitor = Thread(target=monitor_up_interfaces, name="Network Status Monitor", args=(2, notify))
+monitor.start()
+
+import socket
+def is_port_in_use(ip, port):
+    with socket.socket() as s:
+        return s.connect_ex((ip, port)) == 0
+    
+print(get_active_ipv4())

qlsdk/core/utils.py

@@ -22,6 +22,8 @@ def to_channels(data: bytes) -> list[int]:
         if ba[i] == 1:
             m = i % 8
             channels.append(i + 8 - 2 * m)
+            
+    channels.sort()
     return channels
 
 def bytes_to_ints(b):

qlsdk/persist/edf.py

@@ -34,6 +34,7 @@ class EdfHandler(object):
         self._first_pkg_id = None
         self._last_pkg_id = None
         self._first_timestamp = None
+        self._first_time = None
         self._end_time = None
         self._patient_code = "patient_code"
         self._patient_name = "patient_name"
@@ -77,6 +78,7 @@ class EdfHandler(object):
                 self.acc_channels = data.acc_ch_count
                 self._first_pkg_id = data.pkg_id
                 self._first_timestamp = data.time_stamp
+                self._first_time = datetime.now()
                 
             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
@@ -90,8 +92,25 @@ class EdfHandler(object):
         if not self._recording:
             self.start()
     
-    def trigger(self, data):
-        pass        
+    # trigger标记
+    # desc: 标记内容
+    # cur_time: 设备时间时间戳，非设备发出的trigger不要设置
+    def trigger(self, desc, cur_time=None):
+        if self._edf_writer is None:
+            logger.warning("EDF writer未初始化，无法写入trigger标记")
+            return
+        
+        if cur_time is None:
+            onset = datetime.now().timestamp() - self._first_time.timestamp()
+        else:
+            onset = cur_time - self._first_timestamp
+            
+        self._edf_writer.writeAnnotation(onset, 1, desc)
+    
+    
+    # def trigger(self, desc):
+    #     if self._edf_writer:            
+    #         self._edf_writer.writeAnnotation(0, 1, desc)
     
     def start(self):
         self._recording = True