qlsdk2 0.4.0a1__tar.gz → 0.4.0a3__tar.gz

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qlsdk2
-Version: 0.4.0a1
+Version: 0.4.0a3
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun
@@ -12,7 +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
+Requires-Dist: bitarray>=1.5.3
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: twine>=3.0; extra == "dev"

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/setup.py

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

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/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 *

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/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):

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk/core/message/command.py

@@ -1,4 +1,5 @@
 import abc
+from time import time_ns
 from typing import Dict, Type
 from enum import Enum
 from loguru import logger
@@ -26,6 +27,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:
@@ -70,15 +75,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 +92,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
@@ -112,6 +118,7 @@ class GetDeviceInfoCommand(DeviceCommand):
 # 握手
 class HandshakeCommand(DeviceCommand):
     cmd_code = 0x01
+    cmd_desc = "握手"
     
     def parse_body(self, body: bytes):
         logger.info(f"Received handshake response: {body.hex()}")
@@ -119,8 +126,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 +142,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')
@@ -156,6 +166,7 @@ class SetAcquisitionParamCommand(DeviceCommand):
 # 启动采集
 class StartAcquisitionCommand(DeviceCommand):
     cmd_code = 0x452
+    cmd_desc = "启动信号采集"
     
     def pack_body(self):
         return bytes.fromhex('0000')
@@ -165,19 +176,24 @@ class StartAcquisitionCommand(DeviceCommand):
 # 停止采集
 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
+    cmd_desc = "设置阻抗测量参数"
     def parse_body(self, body: bytes):
         logger.info(f"Received SetImpedanceParamCommand response: {body.hex()}")
+        
 # 启动采集
 class StartImpedanceCommand(DeviceCommand):
     cmd_code = 0x412
+    cmd_desc = "启动阻抗测量"
     def pack_body(self):
         body = bytes.fromhex('0000')
         body += to_bytes(self.device.acq_channels)
@@ -190,36 +206,22 @@ class StartImpedanceCommand(DeviceCommand):
 # 停止采集
 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,13 +229,14 @@ 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.warning(f"通道 {channels} 刺激开始")
         # error_type - 1B
         error_type = body[17]
 
 # 停止采集
 class StopStimulationCommand(DeviceCommand):
     cmd_code = 0x488
+    cmd_desc = "停止刺激"
     
     def parse_body(self, body: bytes):
         logger.info(f"Received stimulation stop response: {body.hex()}")
@@ -241,14 +244,25 @@ class StopStimulationCommand(DeviceCommand):
 # 停止采集
 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
+        # 特征位-4B
+        characteristic  = int.from_bytes(body[25:29], 'little')
+        logger.warning(f"[{characteristic}]刺激告警，通道 {channels} 刺激驱动不足")
         
 
 # 阻抗数据
 class ImpedanceDataCommand(DeviceCommand):
     cmd_code = 0x415
+    cmd_desc = "阻抗数据"
     
     def parse_body(self, body: bytes):
         logger.info(f"Received impedance data: {body.hex()}")
@@ -257,19 +271,24 @@ 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:
+    def parse_body(self, body: bytes):                
+        if len(self.device.signal_consumers) > 0 or self.device.edf_handler:
             # 解析数据包
             rsc = RscPacket()
             rsc.transfer(body)
+            
             # 发送数据包到订阅者
             for q in list(self.device.signal_consumers.values()):
                 q.put(rsc)
+                
+            # 文件写入到edf
+            if self.device.edf_handler:
+                self.device.edf_handler.append(rsc)
 
 # =============================================================================
 # Command Registration

qlsdk2-0.4.0a3/src/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")

qlsdk2-0.4.0a3/src/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())

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/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):

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk/persist/rsc_edf.py

@@ -5,10 +5,11 @@ from threading import Thread
 from loguru import logger
 import numpy as np
 import os
+from qlsdk.core import RscPacket
 
 class EDFWriterThread(Thread):
     def __init__(self, edf_writer : EdfWriter):
-        super().__init__(self)
+        super().__init__()
         self._edf_writer : EdfWriter = edf_writer
         self.data_queue : Queue = Queue()
         self._stop_event : bool = False
@@ -21,10 +22,6 @@ class EDFWriterThread(Thread):
         self._channels = []
         self._sample_rate = 0
         
-    def start(self):
-        self._stop_event = False
-        super().start()
-        
     def stop(self):
         self._stop_event = True
         
@@ -32,7 +29,7 @@ class EDFWriterThread(Thread):
         # 数据
         self.data_queue.put(data)
         
-    def _consumer(self):
+    def run(self):
         logger.debug(f"开始消费数据 _consumer: {self.data_queue.qsize()}")
         while True:
             if self._recording or (not self.data_queue.empty()):
@@ -73,7 +70,8 @@ class EDFWriterThread(Thread):
             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}")
+        # logger.info(f"文件: {self.file_name}完成记录, 总点数: {self._points}, 总时长: {self._duration}秒 丢包数: {self._lost_packets}/{self._total_packets + self._lost_packets}")
+        # logger.info(f"文件: 完成记录, 总点数: {self._points}, 总时长: {self._duration}秒 丢包数: {self._lost_packets}/{self._total_packets + self._lost_packets}")
         
     
         
@@ -101,7 +99,7 @@ class RscEDFHandler(object):
         @author: qlsdk
         @since: 0.4.0
     '''
-    def __init__(self, sample_frequency, physical_max, physical_min, digital_max, digital_min, resolution=32, storage_path = None):
+    def __init__(self, sample_frequency, physical_max, physical_min, digital_max, digital_min, resolution=24, storage_path = None):
         # edf文件参数
         self.physical_max = physical_max
         self.physical_min = physical_min
@@ -137,7 +135,7 @@ class RscEDFHandler(object):
         self._end_time = None
         self._patient_code = "patient_code"
         self._patient_name = "patient_name"
-        self._device_type = None
+        self._device_type = "24130032"
         self._total_packets = 0
         self._lost_packets = 0
         self._storage_path = storage_path
@@ -170,32 +168,39 @@ class RscEDFHandler(object):
     def set_patient_name(self, patient_name):
         self._patient_name = patient_name
     
-    def append(self, data, channels=None):
-        if self._edf_writer_thread is None:
-            self._edf_writer_thread = EDFWriterThread(self.init_edf_writer())
-            self._edf_writer_thread.start()
-            self._recording = True
-            self._edf_writer_thread._recording = True
-            logger.info(f"开始写入数据: {self.file_name}")
+    def append(self, data: RscPacket):
             
         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.eeg_channels is None:
+                logger.info(f"开始记录数据到文件...")
+                self.eeg_channels = data.channels
+                self._first_pkg_id = data.pkg_id if self._first_pkg_id is None else self._first_pkg_id
+                self._first_timestamp = data.time_stamp if self._first_timestamp is None else self._first_timestamp
                 
-            # 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}")
+            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)
+        
+            
+        # 通道数变化、采样频率、信号放大幅度变化时应生成新的edf文件，handler内部不关注，外部调用方自行控制
+        # elif len(self.eeg_channels) != len(data.channels):
+        
+            if self._edf_writer_thread is None:
+                self._edf_writer_thread = EDFWriterThread(self.init_edf_writer())
+                self._edf_writer_thread.start()
+                self._recording = True
+                self._edf_writer_thread._recording = True
+                logger.info(f"开始写入数据: {self.file_name}")
+                
         self._edf_writer_thread.append(data)
+            
+        # 数据
+        # self._cache.put(data)
+        # self._edf_writer_thread.append(data)
         # if not self._recording:
         #     self.start()
     
@@ -206,7 +211,7 @@ class RscEDFHandler(object):
         # 创建EDF+写入器
         edf_writer = EdfWriter(
             self.file_name,
-            self.eeg_channels,
+            len(self.eeg_channels),
             file_type=self.file_type
         )
         
@@ -218,7 +223,7 @@ class RscEDFHandler(object):
         
         # 配置通道参数
         signal_headers = []
-        for ch in range(self.eeg_channels):
+        for ch in range(len(self.eeg_channels)):
             signal_headers.append({
                 "label": f'channels {ch + 1}',
                 "dimension": 'uV',

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk/rsc/device_manager.py

@@ -1,16 +1,18 @@
 import socket
+from typing import Optional
 from loguru import logger   
 from qlsdk.rsc.discover import UdpBroadcaster
 from threading import Thread
 from qlsdk.core import *
 from qlsdk.rsc.entity import QLDevice
 from qlsdk.rsc.proxy import DeviceProxy
+import time
         
         
 class DeviceContainer(object):
-    def __init__(self, proxy_enabled=False):
+    def __init__(self, proxy_enabled=False, tcp_port = 19216):
         self._devices = {}
-        self._tcp_port = 19216
+        self._tcp_port = tcp_port
         self._proxy_enabled = proxy_enabled
         
         # 设备搜索广播器
@@ -21,6 +23,25 @@ class DeviceContainer(object):
         self._listening_thread = Thread(target=self._listening)
         self._listening_thread.daemon = True
         self._listening_thread.start()
+        
+    @property
+    def devices(self)-> QLDevice:
+        return self._devices
+    
+    '''
+        等待设备连接
+    '''
+    def connect(self, device_id: str, timeout:int=30) -> Optional[QLDevice]:        
+        logger.info(f"Searching for device: {device_id}")
+        self.add_search(device_id)
+        for _ in range(timeout):
+            device = self.get_device(device_id)
+            if device:
+                logger.success(f"Device {device_id} connected")
+                return device
+            time.sleep(1)
+        logger.error(f"Device {device_id} not found")
+        return None
             
     def _listening(self):
         tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -53,6 +74,7 @@ class DeviceContainer(object):
     def client_handler(self, client_socket):
                 
         if self._proxy_enabled:
+            # 启动代理  TODO: 代理的同时支持接口控制和数据转发
             proxy = DeviceProxy(client_socket)
             proxy.start()
         else:            
@@ -65,6 +87,7 @@ class DeviceContainer(object):
             # 添加设备
             while True:
                 if device.device_name:
+                    logger.info(f"设备 {device.device_name} 已连接")
                     self.add_device(device)
                     break
             
@@ -84,7 +107,7 @@ class DeviceContainer(object):
         logger.debug(f"add_device {device.device_name} then has broadcaster {self._broadcaster}")
         
     def get_device(self, device_id=None)->QLDevice:
-        logger.debug(f"已连接设备数量:{len(self._devices)}")
+        logger.trace(f"已连接设备数量:{len(self._devices)}")
         if len(self._devices) == 0:
             return None
         

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk/rsc/discover.py

@@ -6,6 +6,7 @@ from loguru import logger
 from qlsdk.core.message import UDPMessage
 
 class UdpBroadcaster:
+    # 广播端口需要和ar4sdk做区分， 使用54366时不能和x8同时使用
     def __init__(self, port=54366):
         self.broadcast_port = port
         self.devices_to_broadcast = []  # 待广播的设备序列号列表

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk/rsc/entity.py

@@ -1,12 +1,13 @@
 from multiprocessing import Queue, Process
 from typing import Any, Dict, Literal
-# from rsc.command import *
-from qlsdk.core import *
-from qlsdk.core.device import BaseDevice
 from threading import Thread
 from loguru import logger
 from time import time_ns
 
+from qlsdk.core import *
+from qlsdk.core.device import BaseDevice
+from qlsdk.persist import RscEDFHandler
+
 class QLDevice(BaseDevice):
     def __init__(self, socket):
         self.socket = socket
@@ -101,6 +102,9 @@ class QLDevice(BaseDevice):
         self.__signal_consumer: Dict[str, Queue[Any]]={}
         self.__impedance_consumer: Dict[str, Queue[Any]]={}
         
+        # EDF文件处理器
+        self._edf_handler = None       
+        self.storage_enable = True 
         
         self._parser = DeviceParser(self)
         self._parser.start()
@@ -109,6 +113,19 @@ class QLDevice(BaseDevice):
         self._accept = Thread(target=self.accept)
         self._accept.daemon = True
         self._accept.start()
+        
+    def init_edf_handler(self):
+        self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range, - self.sample_range, - 2 >> 24,  2 >> 24 - 1, self.resolution)  
+        
+    @property
+    def edf_handler(self):
+        if not self.storage_enable:
+            return None
+        
+        if self._edf_handler is None:
+            self.init_edf_handler() 
+            
+        return self._edf_handler  
     
     @property
     def acq_channels(self):
@@ -128,11 +145,13 @@ class QLDevice(BaseDevice):
     @property
     def signal_consumers(self):
         return self.__signal_consumer
-        return self.__signal_consumer
     
     @property
     def impedance_consumers(self):
         return self.__impedance_consumer
+    
+    def set_storage_path(self, path):
+        pass
         
     def accept(self):
         while True:
@@ -221,13 +240,16 @@ class QLDevice(BaseDevice):
         msg = StopAcquisitionCommand.build(self).pack()
         logger.debug(f"stop_acquisition message is {msg}")
         self.socket.sendall(msg)
+        if self._edf_handler:
+            # 发送结束标识
+            self.edf_handler.append(None)
         
     # 订阅实时数据
     def subscribe(self, topic:str=None, q : Queue=None, type : Literal["signal","impedance"]="signal"):  
             
         # 数据队列
         if q is None:
-            q = Queue()
+            q = Queue(maxsize=1000)
             
         # 队列名称     
         if topic is None:
@@ -319,7 +341,7 @@ class DeviceParser(object):
         
     def append(self, buffer):
         self.cache += buffer
-        logger.debug(f"append cache len: {len(self.cache)}")
+        logger.debug(f"已缓存的数据长度: {len(self.cache)}")
         
         # if not self.running:
         #     self.start()
@@ -327,14 +349,13 @@ class DeviceParser(object):
     def __parser__(self):
         logger.info("数据解析开始")
         while self.running:
-            # logger.debug(f" cache len: {len(self.cache)}")
             if len(self.cache) < 14:
                 continue
             if self.cache[0] != 0x5A or self.cache[1] != 0xA5:
                 self.cache = self.cache[1:]
                 continue
             pkg_len = int.from_bytes(self.cache[8:12], 'little')
-            logger.debug(f" cache len: {len(self.cache)}, pkg_len len: {len(self.cache)}")
+            logger.trace(f" cache len: {len(self.cache)}, pkg_len len: {len(self.cache)}")
             # 一次取整包数据
             if len(self.cache) < pkg_len:
                 continue
@@ -369,11 +390,13 @@ class TCPMessage(object):
         TCPMessage._validate_packet(data)
         # 提取指令码
         cmd_code = int.from_bytes(data[TCPMessage.CMD_POS:TCPMessage.CMD_POS+2], 'little')
-        logger.debug(f"收到指令：{hex(cmd_code)}")
         cmd_class = CommandFactory.create_command(cmd_code)
-        logger.debug(f"Command class: {cmd_class}")
+        logger.debug(f"收到指令：{cmd_class.cmd_desc}[{hex(cmd_code)}]")
         instance = cmd_class(device)
+        start = time_ns()
+        logger.debug(f"开始解析: {start}")
         instance.parse_body(data[TCPMessage.HEADER_LEN:-2])
+        logger.debug(f"解析完成:{time_ns()}, 解析耗时：{time_ns() - start}ns")
         return instance
 
     @staticmethod
@@ -389,9 +412,9 @@ class TCPMessage(object):
         if len(data) != expected_len:
             raise ValueError(f"Length mismatch: {len(data)} vs {expected_len}")
         
-        logger.debug(f"checksum: {int.from_bytes(data[-2:], 'little')}")
-        checksum = crc16(data[:-2])
-        logger.debug(f"checksum recv: {checksum}")
+        # logger.trace(f"checksum: {int.from_bytes(data[-2:], 'little')}")
+        # checksum = crc16(data[:-2])
+        # logger.trace(f"checksum recv: {checksum}")
         
         
         
@@ -403,150 +426,3 @@ class DataPacket(object):
         
     def parse_body(self, body: bytes):
         raise NotImplementedError("Subclasses should implement this method")
-  
-    
-
-class C64Channel(Enum):
-    CH0 = 0
-    CH1 = 1
-    CH2 = 2
-    CH3 = 3
-    CH4 = 4
-    CH5 = 5
-    CH6 = 6
-    CH7 = 7
-    CH8 = 8
-    CH9 = 9
-    CH10 = 10
-    CH11 = 11
-    CH12 = 12
-    CH13 = 13
-    CH14 = 14
-    CH15 = 15
-
-class WaveForm(Enum):
-    DC = 0
-    SQUARE = 1
-    AC = 2
-    CUSTOM = 3
-    PULSE = 4
-
-#  # 刺激通道 
-# class StimulationChannel(object):
-#     def __init__(self, channel_id: int, waveform: int, current: float, duration: float, ramp_up: float = None, ramp_down: float = None,
-#                  frequency: float = None, phase_position: int = None, duration_delay: float = None, pulse_width: int = None, pulse_width_rate: int = 1):
-#         self.channel_id = channel_id
-#         self.waveform = waveform
-#         self.current_max = current
-#         self.current_min = current
-#         self.duration = duration
-#         self.ramp_up = ramp_up
-#         self.ramp_down = ramp_down
-#         self.frequency = frequency
-#         self.phase_position = phase_position
-#         self.duration_delay = duration_delay
-#         self.pulse_width = pulse_width 
-#         self.delay_time = 0
-#         self.pulse_interval = 0
-#         self.with_group_repeats = 1
-#         self.pulse_width_rate = 1065353216
-#         self.pulse_time_f = 0
-#         self.pulse_time_out = 0
-#         self.pulse_time_idle = 0
-    
-#     def to_bytes(self):
-#         # Convert the object to bytes for transmission
-#         result = self.channel_id.to_bytes(1, 'little')
-#         wave_form = WaveForm.SQUARE.value if self.waveform == WaveForm.PULSE.value else self.waveform
-#         result += wave_form.to_bytes(1, 'little')
-#         result += int(self.current_max * 1000 * 1000).to_bytes(4, 'little')
-#         # result += int(self.current_min * 1000).to_bytes(2, 'little')
-#         result += int(self.frequency).to_bytes(2, 'little')
-#         result += int(self.pulse_width).to_bytes(2, 'little')
-#         result += int(self.pulse_width_rate).to_bytes(4, 'little')
-        
-#         result += int(self.pulse_interval).to_bytes(2, 'little')
-#         result += int(self.with_group_repeats).to_bytes(2, 'little')
-#         result += int(self.pulse_time_f).to_bytes(4, 'little')
-#         result += int(self.pulse_time_out).to_bytes(4, 'little')
-#         result += int(self.pulse_time_idle).to_bytes(4, 'little')
-        
-#         result += int(self.delay_time).to_bytes(4, 'little')
-#         result += int(self.ramp_up * 1000).to_bytes(4, 'little')
-#         result += int((self.duration + self.ramp_up)  * 1000).to_bytes(4, 'little')
-#         result += int(self.ramp_down * 1000).to_bytes(4, 'little')
-        
-#         return result
-    
-#     def to_json(self):
-#         return {
-#             "channel_id": self.channel_id,
-#             "waveform": self.waveform,
-#             "current_max": self.current_max,
-#             "current_min": self.current_min,
-#             "duration": self.duration,
-#             "ramp_up": self.ramp_up,
-#             "ramp_down": self.ramp_down,
-#             "frequency": self.frequency,
-#             "phase_position": self.phase_position,
-#             "duration_delay": self.duration_delay,
-#             "pulse_width": self.pulse_width,
-#             "delay_time": self.delay_time,
-#             "pulse_interval": self.pulse_interval,
-#             "with_group_repeats": self.with_group_repeats
-#         }
-        
-# # 刺激范式
-# class StimulationParadigm(object):
-#     def __init__(self):
-#         self.channels = None
-#         self.duration = None
-#         self.interval_time = 0
-#         self.characteristic = 0
-#         self.mode = 0
-#         self.repeats = 0
-        
-#     def add_channel(self, channel: StimulationChannel, update=False):
-#         if self.channels is None:
-#             self.channels = {}
-#         channel_id = channel.channel_id + 1
-#         if channel_id in self.channels.keys():
-#             logger.warning(f"Channel {channel_id} already exists")
-#             if update:
-#                 self.channels[channel_id] = channel
-#         else:
-#             self.channels[channel_id] = channel  
-            
-#         # 计算刺激时间
-#         duration = channel.duration + channel.ramp_up + channel.ramp_down     
-#         if self.duration is None or duration > self.duration:
-#             self.duration = duration 
-        
-        
-#     def to_bytes(self):
-#         result = to_bytes(list(self.channels.keys()), 64)
-#         result += int(self.duration * 1000).to_bytes(4, 'little')
-#         result += int(self.interval_time).to_bytes(4, 'little')
-#         result += int(self.characteristic).to_bytes(4, 'little')
-#         result += int(self.mode).to_bytes(1, 'little')
-#         result += int(self.repeats).to_bytes(4, 'little')
-#         for channel in self.channels.values():
-#             result += channel.to_bytes()
-#         return result
-    
-#     def to_json(self):
-#         # Convert the object to JSON for transmission
-#         return {
-#             "channels": list(self.channels.keys()),
-#             "duration": self.duration,
-#             "interval_time": self.interval_time,
-#             "characteristic": self.characteristic,
-#             "mode": self.mode,
-#             "repeats": self.repeats, 
-#             "stim": [channel.to_json() for channel in self.channels.values()]
-#         }
-        
-    # @staticmethod
-    # def from_json(param: Dict[str, Any]):
-    #     pass
-

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk/rsc/paradigm.py

@@ -186,19 +186,22 @@ class PulseStimulation(StimulationChannel):
         channel_id: int,  通道编号，从0开始
         current: float,  电流值，单位为mA
         duration: float,  刺激时间，单位为秒
+        frequency: float,  频率，单位为Hz
+        pulse_width: int,  脉冲宽度，单位为uS
+        pulse_width_ratio: float,  脉冲宽度比，范围(0, 1)
+        pulse_interval: int 脉冲间隔，单位为uS
         ramp_up: float,  上升时间，单位为秒
         ramp_down: float,  下降时间，单位为秒
-        frequency: float,  频率，单位为Hz
-        phase_position: int,  相位位置，单位为度
+        delay_time: float,  延迟启动时间，单位为秒（暂未启用）
     '''
     def __init__(self, channel_id: int, current: float, duration: float, frequency: float,  pulse_width: int, 
-                 pulse_width_ratio: float = 1, ramp_up: float = 0, ramp_down: float = 0, delay_time = 0):
+                 pulse_width_ratio: float = 1, pulse_interval = 0, ramp_up: float = 0, ramp_down: float = 0, delay_time = 0):
         super().__init__(channel_id, WaveForm.PULSE.value, current, duration, ramp_up, ramp_down)
         self.frequency = frequency
-        self.duration_delay = delay_time
+        self.delay_time = delay_time
         self.pulse_width = pulse_width 
         self.pulse_width_ratio = pulse_width_ratio
-        self.pulse_interval = 0
+        self.pulse_interval = pulse_interval
         self.with_group_repeats = 1
         self.pulse_time_f = 0
         self.pulse_time_out = 0

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qlsdk2
-Version: 0.4.0a1
+Version: 0.4.0a3
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun
@@ -12,7 +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
+Requires-Dist: bitarray>=1.5.3
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: twine>=3.0; extra == "dev"

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk2.egg-info/SOURCES.txt

@@ -23,6 +23,8 @@ src/qlsdk/core/message/__init__.py
 src/qlsdk/core/message/command.py
 src/qlsdk/core/message/tcp.py
 src/qlsdk/core/message/udp.py
+src/qlsdk/core/network/__init__.py
+src/qlsdk/core/network/monitor.py
 src/qlsdk/persist/__init__.py
 src/qlsdk/persist/edf.py
 src/qlsdk/persist/rsc_edf.py

{qlsdk2-0.4.0a1 → qlsdk2-0.4.0a3}/src/qlsdk2.egg-info/requires.txt

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