qlsdk2 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

qlsdk/rsc/device/c16_rs.py

@@ -0,0 +1,185 @@
+
+from multiprocessing import Queue
+from threading import Thread
+from time import sleep, time_ns
+from typing import Any, Dict, Literal
+
+from loguru import logger
+from qlsdk.persist import RscEDFHandler
+from qlsdk.rsc.device.device_factory import DeviceFactory
+from qlsdk.rsc.interface import IDevice
+from qlsdk.rsc.command import *
+from qlsdk.rsc.device.base import QLBaseDevice
+
+'''
+    C16RS设备类，继承自QLBaseDevice
+    提供设备特定的属性和方法，包括设备类型、采集参数设置、电刺激参
+'''
+class C16RS(QLBaseDevice):
+    
+    device_type = 0x339  # C16RS设备类型标识符
+    
+    def __init__(self, socket):
+        
+        super().__init__(socket)
+        # 存储通道反向映射位置值
+        self._reverse_ch_pos  = None    
+        
+        self.channel_name_mapping = {
+            "FP1": 1, 
+            "FP2": 2, 
+            "C3": 3, 
+            "C4": 4, 
+            "O1": 5, 
+            "O2": 6, 
+            "CZ": 7, 
+            "T7": 8,
+            "T8": 9, 
+            "M1": 10, 
+            "M2": 11, 
+            "F3": 12, 
+            "F4": 13, 
+            "FZ": 14, 
+            "F7": 15, 
+            "F8": 16, 
+            "PZ": 17, 
+            "P3": 18, 
+            "P7": 19, 
+            "P4": 20, 
+            "P8": 21,
+            "T3": 8,
+            "T4": 9, 
+            "A1": 10, 
+            "A2": 11, 
+        }
+        
+        self.channel_mapping = {
+            "1": 59, 
+            "2": 60, 
+            "3": 53, 
+            "4": 50, 
+            "5": 51, 
+            "6": 64, 
+            "7": 49, 
+            "8": 63,
+            "9": 24, 
+            "10": 14, 
+            "11": 10, 
+            "12": 11, 
+            "13": 57, 
+            "14": 16, 
+            "15": 55, 
+            "16": 15, 
+            "17": 40, 
+            "18": 37, 
+            "19": 34, 
+            "20": 18, 
+            "21": 47
+        }
+        
+        self.channel_display_mapping = {
+            59: 1, 
+            60: 2, 
+            53: 3, 
+            50: 4, 
+            51: 5, 
+            64: 6, 
+            49: 7, 
+            63: 8,
+            24: 9, 
+            14: 10, 
+            10: 11, 
+            11: 12, 
+            57: 13, 
+            16: 14, 
+            55: 15, 
+            15: 16, 
+            40: 17, 
+            37: 18, 
+            34: 19, 
+            18: 20, 
+            47: 21
+        }
+    
+    
+    @classmethod
+    def from_parent(cls, parent:IDevice) -> IDevice:
+        rlt = cls(parent.socket)
+        rlt.device_id = parent.device_id
+        rlt._device_no = parent.device_no
+        return rlt  
+        
+    def init_edf_handler(self):
+        self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution, record_duration = self._record_duration)  
+        self._edf_handler.set_device_type(self.device_type)
+        self._edf_handler.set_device_no(self.device_no)
+        self._edf_handler.set_storage_path(self._storage_path)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C16R')
+            
+    # 设置刺激参数
+    def set_stim_param(self, param):
+        self.stim_paradigm = param
+    
+    # 设置采集参数
+    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+        # 保存原始通道参数
+        self._acq_param["original_channels"] = channels
+        
+        # 名称转换为数字通道  
+        channels = [self.channel_name_mapping.get(str(i).upper(), i) for i in channels]
+        
+        # 根据映射关系做通道转换-没有映射的默认到第一个通道
+        # 先设置不存在的通道为-1，再把-1替换为第一个通道，避免第一个通道也不合法的情况
+        channels = [self.channel_mapping.get(str(i), -1) for i in channels]
+        channels = [i if i != -1 else channels[0] for i in channels]
+                
+        # 更新采集参数
+        self._acq_param["channels"] = channels
+        self._acq_param["sample_rate"] = sample_rate
+        self._acq_param["sample_range"] = sample_range
+        self._acq_channels = channels
+        self._sample_rate = sample_rate
+        self._sample_range = sample_range
+        
+        logger.debug(f"C16RS: set_acq_param: {self._acq_param}")   
+        
+        # 参数改变后，重置通道位置映射
+        self._reverse_ch_pos  = None  
+    
+    # 信号数据转换(默认不处理)
+    def _signal_wrapper(self, data: RscPacket):
+        if data is None:
+            return
+        # 根据映射关系做通道转换-（注意数据和通道的一致性）
+        # data.channels = [self.channel_display_mapping.get(i, i) for i in data.channels]
+        
+        # 升级为类变量，减少计算
+        if self._reverse_ch_pos is None:
+            self._reverse_ch_pos = map_indices(self._acq_param["channels"], data.channels)
+        
+        # 更新通道（数据）顺序和输入一致
+        data.channels = self._acq_param["original_channels"]
+        data.eeg = [data.eeg[i] for i in self._reverse_ch_pos]
+        
+        
+def map_indices(A, B):
+    """
+    
+    参数:
+        A: 源数组（无重复值）
+        B: 目标数组（无重复值）
+    
+    返回:
+        C: 与A长度相同的数组，元素为A中对应值在B中的索引（不存在则为-1）
+    """
+    # 创建B的值到索引的映射字典（O(n)操作）
+    b_map = {value: idx for idx, value in enumerate(B)}
+    
+    # 遍历A，获取每个元素在B中的位置（O(m)操作）
+    return [b_map.get(a, -1) for a in A]
+                
+    
+# Register the C16RS device with the DeviceFactory
+DeviceFactory.register(C16RS.device_type, C16RS) 
+    
+    

qlsdk/rsc/device/c256_rs.py

@@ -16,6 +16,7 @@ class C256RS(QLBaseDevice):
     device_type = 0x40  # C64RS设备类型标识符
     
     def __init__(self, socket):
+        super().__init__(socket)
         self.socket = socket
         
         self._id = None

qlsdk/rsc/device/c64_rs.py

@@ -16,6 +16,7 @@ class C64RS(QLBaseDevice):
     device_type = 0x39  # C64RS设备类型标识符
     
     def __init__(self, socket):
+        super().__init__(socket)
         self.socket = socket
         
         self._id = None
@@ -145,9 +146,9 @@ class C64RS(QLBaseDevice):
     def init_edf_handler(self):
         self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
         self._edf_handler.set_device_type(self.device_type)
-        self._edf_handler.set_device_no(self.device_name)
+        self._edf_handler.set_device_no(self.device_no)
         self._edf_handler.set_storage_path(self._storage_path)
-        self._edf_handler.set_file_prefix(self._file_prefix)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C64RS')
         
     @property
     def edf_handler(self):

qlsdk/rsc/device/c64s1.py

@@ -16,6 +16,7 @@ class C64S1(QLBaseDevice):
     device_type = 0x40  # C64RS设备类型标识符
     
     def __init__(self, socket):
+        super().__init__(socket)
         self.socket = socket
         
         self._id = None
@@ -151,9 +152,9 @@ class C64S1(QLBaseDevice):
     def init_edf_handler(self):
         self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
         self._edf_handler.set_device_type(self.device_type)
-        self._edf_handler.set_device_no(self.device_name)
+        self._edf_handler.set_device_no(self.device_no)
         self._edf_handler.set_storage_path(self._storage_path)
-        self._edf_handler.set_file_prefix(self._file_prefix)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C64S1')
         
     @property
     def edf_handler(self):

qlsdk/rsc/device/device_factory.py

@@ -16,7 +16,7 @@ class DeviceFactory(object):
     
     @classmethod
     def create_device(cls, device: IDevice) -> Type[IDevice]:
-        logger.debug(f"Creating device for device type: {hex(device.device_type)}, support types: {cls._devices.keys()}")
+        logger.trace(f"Creating device for device type: {hex(device.device_type)}, support types: {cls._devices.keys()}")
         if device.device_type not in cls._devices.keys():
             logger.warning(f"不支持的设备类型: {hex(device.device_type)}")
             raise ValueError(f"Unsupported device type: {hex(device.device_type)}")
@@ -26,6 +26,7 @@ class DeviceFactory(object):
 
 # Register the C64RS device with the DeviceFactory    
 DeviceFactory.register(C64RS.device_type, C64RS)
+# Register the ARSKindling device with the DeviceFactory
 DeviceFactory.register(ARSKindling.device_type, ARSKindling) 
 
 

qlsdk/rsc/interface/device.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 import abc
+from typing import Literal
 
 class  IDevice(ABC):     
     
@@ -11,10 +12,22 @@ class  IDevice(ABC):
     def set_device_type(self, value: int):
         pass
     
+    def set_storage_path(self, path: str):
+        pass
+    
+    def set_file_prefix(self, pre: str):
+        pass
+    
+    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+        pass
+    
     @property
     def device_no(self) -> str:
         pass
     
+    def produce(self, data, type:Literal['signal', 'impedance']="signal") -> None:
+        pass
+    
     def start_listening(self):
         pass
     

qlsdk/rsc/manager/container.py

@@ -33,15 +33,15 @@ class DeviceContainer(object):
         等待设备连接
     '''
     def connect(self, device_id: str, timeout:int=30) -> Optional[IDevice]:        
-        logger.info(f"Searching for device: {device_id}")
+        logger.info(f"开始搜索设备: {device_id}")
         self.add_search(device_id)
         for s in range(timeout):
             device = self.get_device(device_id)
             if device:
-                logger.success(f"Device {device_id} connected")
+                logger.success(f"设备[{device_id}]已连接成功。")
                 return device
             time.sleep(1)
-        logger.error(f"Device {device_id} not found")
+        logger.warning(f"在{timeout}内未搜索到设备：{device_id}")
         return None
             
     def _listening(self):
@@ -50,24 +50,30 @@ class DeviceContainer(object):
         try:
             # 绑定到所有接口的19216端口
             tcp_socket.bind(('0.0.0.0', self._tcp_port))
-            tcp_socket.listen(5)
+            tcp_socket.listen(100)
             logger.info(f"端口[{self._tcp_port}]监听服务已启动")
 
             while True:
                 client_socket, addr = tcp_socket.accept()
-                logger.info(f"接收到来自 {addr[0]}:{addr[1]} 的连接")
+                logger.info(f"接收到来自[{addr[0]}:{addr[1]}]的连接，待确认设备类型...")
                 
                 
                 # 为每个新连接创建线程处理
-                client_handler = Thread(
-                    target=self.client_handler,
-                    args=(client_socket,)
-                )
-                client_handler.daemon = True
-                client_handler.start()
+                try:
+                    client_handler = Thread(
+                        target=self.client_handler,
+                        args=(client_socket,),
+                        daemon=False
+                    )
+                    
+                    client_handler.start()
+                except Exception as e:
+                    logger.error(f"Handler Error: {e}")
                 
         except KeyboardInterrupt:
             logger.error(f"端口[{self._tcp_port}]监听服务异常关闭")
+        except Exception as e:
+            logger.error(f"端口[{self._tcp_port}]监听服务异常: {e}")
         finally:
             logger.error(f"端口[{self._tcp_port}]监听服务关闭")
             tcp_socket.close()
@@ -84,18 +90,16 @@ class DeviceContainer(object):
             device.start_listening()
             # GET_DEVICE_INFO
             msg = GetDeviceInfoCommand.build(device).pack()
-            logger.info(f"发送获取设备信息命令: {msg.hex()}")
+            logger.trace(f"发送获取设备信息命令: {msg.hex()}")
             device.send(msg)
-            logger.info(f"base device {dir(device)}")
             # 添加设备
             while True:
                 if device.device_name:
-                    logger.info(f"设备 {device.device_name} 已连接")
                     real_device = DeviceFactory.create_device(device)
                     device.stop_listening()
                     real_device.start_listening()
                     self.add_device(real_device)
-                    logger.info(f"real_device consumers {len(real_device.signal_consumers)}")
+                    logger.info(f"设备[{device.device_name}]已连接，设备类型为：{hex(real_device.device_type)}")
                     break
             
         
@@ -107,20 +111,20 @@ class DeviceContainer(object):
         if device is None or device.device_no is None:
             logger.warning("无效的设备")
             
-        self._devices.update({device.device_no: device})
-        logger.debug(f"add_device {device.device_no} then has devices {self._devices}")
+        self._devices[device.device_no] = device
+        logger.info(f"添加设备[{device.device_no}]到设备列表，已连接设备数量：{len(self._devices)}")
         
-        self._broadcaster.remove_device(device.device_no)
-        logger.debug(f"add_device {device.device_no} then has broadcaster {self._broadcaster}")
+        # 标记设备为已连接
+        self._broadcaster.mark_device_as_connected(device.device_no)
         
-    def get_device(self, device_id=None)->IDevice:
-        logger.trace(f"已连接设备数量:{len(self._devices)}")
+    def get_device(self, device_no:str=None)->IDevice:
+        logger.info(f"已连接设备数量:{len(self._devices)}")
         if len(self._devices) == 0:
             return None
         
         # 未指定device_id，返回第一个设备
-        if device_id is None:
+        if device_no is None:
             return list(self._devices.values())[0]
         
-        return self._devices.get(device_id)
+        return self._devices.get(device_no, None)
             

qlsdk/rsc/network/discover.py

@@ -5,6 +5,11 @@ from loguru import logger
 
 from qlsdk.core.message import UDPMessage
 
+'''
+    广播器类，用于发送和接收设备广播消息
+    主要功能：发送设备搜索消息，接收设备连接消息
+    注意：广播端口需要和ar4sdk做区分，使用54366时不能和x8同时使用
+'''
 class UdpBroadcaster:
     # 广播端口需要和ar4sdk做区分， 使用54366时不能和x8同时使用
     def __init__(self, port=54366):
@@ -18,70 +23,54 @@ class UdpBroadcaster:
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
 
+    # 添加设备序列号到待广播列表
     def add_device(self, device_id):
-        """添加设备序列号到待广播列表"""
+        
         with self.lock:
             if device_id not in self.devices_to_broadcast:
                 self.devices_to_broadcast.append(device_id)
-                logger.info(f"Added device {device_id} to broadcast list.")
+                logger.info(f"添加设备[{device_id}]到搜索列表。")
 
+    # 从待广播列表移除设备序列号
     def remove_device(self, device_id):
-        """从待广播列表中移除设备序列号"""
+        
         with self.lock:
             if device_id in self.devices_to_broadcast:
                 self.devices_to_broadcast.remove(device_id)
-                logger.info(f"Removed device {device_id} from broadcast list.")
+                logger.info(f"把设备[{device_id}]从搜索列表中移除。")
 
+    # 把设备标记为已连接
     def mark_device_as_connected(self, device_id):
-        """将设备标记为已连接，并从未广播列表中移除"""
         with self.lock:
+            # 如果设备已连接，则从搜索列表中移除
             if device_id in self.devices_to_broadcast:
                 self.devices_to_broadcast.remove(device_id)
+                
+            # 添加到已连接设备集合
             self.connected_devices.add(device_id)
-            logger.info(f"Device {device_id} is now connected.")
+            
+            logger.info(f"设备[{device_id}]已连接，从搜索列表中移除。")
 
+    # 广播设备信息，寻求配对
     def broadcast_devices(self):
-        """轮询发送广播"""
+        
         while self.running:
             with self.lock:
                 for device_id in self.devices_to_broadcast:
                     message = UDPMessage.search(device_id)
                     self.sock.sendto(message, ('<broadcast>', self.broadcast_port))
-                    logger.info(f"Broadcasting device ID: {device_id}")
-            time.sleep(1)  # 每隔1秒发送一次广播
+                    logger.debug(f"设备[{device_id}]广播消息已发送。")
+                
+            # 每隔1秒发送一次广播    
+            time.sleep(1)  
 
     def start(self):
         """启动广播线程"""
-        self.broadcast_thread = Thread(target=self.broadcast_devices)
-        self.broadcast_thread.setDaemon(True)
+        self.broadcast_thread = Thread(target=self.broadcast_devices, daemon=True)
         self.broadcast_thread.start()
 
     def stop(self):
         """停止广播"""
         self.running = False
         self.broadcast_thread.join()
-        self.sock.close()
-
-# 示例使用
-if __name__ == "__main__":
-    broadcaster = UdpBroadcaster()
-
-    # 添加设备序列号到待广播列表
-    broadcaster.add_device_to_broadcast("390024130032")
-
-    # 启动广播
-    broadcaster.start()
-
-    try:
-        # 模拟运行一段时间
-        time.sleep(10)
-
-        # 标记设备为已连接
-        broadcaster.mark_device_as_connected("390024130032")
-
-        # 继续运行一段时间
-        time.sleep(10)
-
-    finally:
-        # 停止广播
-        broadcaster.stop()
+        self.sock.close()

qlsdk/rsc/parser/base-new.py

@@ -0,0 +1,135 @@
+from enum import Enum
+import threading
+import collections
+from typing import Optional
+
+from loguru import logger
+from qlsdk.rsc.interface import IDevice, IParser
+from qlsdk.rsc.command import CommandFactory
+
+# 解析状态机
+class ParserState(Enum):
+    FIND_HEADER = 1
+    READ_LENGTH = 2
+    READ_BODY = 3
+
+class TcpMessageParser(IParser):
+    HEADER = b'\x5a\xa5'
+    HEADER_LEN = 14
+    MAX_PKG_LEN = 1 * 1024 * 1024        # 1 MB
+    MAX_BUF_LEN = 100 * 1024 * 1024       # 10 MB
+    READ_CHUNK = 4096
+
+    def __init__(self, device: IDevice):
+        self.device = device
+
+        # 生产者-消费者缓冲区：线程安全 deque + bytearray
+        self._buf = bytearray()
+        self._lock = threading.Lock()
+        self._not_empty = threading.Condition(self._lock)
+
+        self._running = threading.Event()
+
+    # ---------- 生产者 ----------
+    def append(self, data: bytes) -> None:
+        logger.info(f"接收数据: {data.hex()}")
+        with self._not_empty:
+            if len(self._buf) + len(data) > self.MAX_BUF_LEN:
+                logger.warning("缓冲区超限，丢弃旧数据")
+                self._buf.clear()
+            self._buf.extend(data)
+            self._not_empty.notify()
+
+    # ---------- 消费者 ----------
+    def start(self) -> None:
+        self._running.set()
+        self._thread = threading.Thread(target=self._parser_loop, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._running.clear()
+        with self._not_empty:
+            self._not_empty.notify_all()
+        self._thread.join(timeout=1)
+
+    # ---------- 解析主循环 ----------
+    def _parser_loop(self) -> None:
+        """状态机：找头 -> 读长度 -> 读体 -> 校验 -> 投递"""
+        state = ParserState.FIND_HEADER
+        need = len(self.HEADER)
+        header_pos = 0
+        pkg_len = 0
+        logger.info("数据解析开始")
+
+        while self._running.is_set():
+            with self._not_empty:
+                while len(self._buf) < need:
+                    if not self._running.is_set():
+                        return
+                    self._not_empty.wait(timeout=0.1)
+
+                view = memoryview(self._buf)  # 零拷贝视图
+
+                if state == ParserState.FIND_HEADER:
+                    # idx = view.find(self.HEADER)
+                    # if idx == -1:
+                    #     # 整段数据都没有头，全部丢弃
+                    #     del self._buf[:len(self._buf) - 1]
+                    #     continue
+                    # # 去掉头部之前可能残留的脏数据
+                    # del self._buf[:idx]
+                    # state = 'READ_LENGTH'
+                    # need = self.HEADER_LEN
+                    # continue
+                    with self._not_empty:
+                        while len(view) < need:
+                            if not self._running.is_set():
+                                return
+                            self._not_empty.wait(timeout=0.1)
+
+                    # 1. 用 bytearray.find 找包头
+                    idx = view.find(self.HEADER)
+                    if idx == -1:
+                        # 没有包头，保留最后 len(self.HEADER)-1 个字节即可
+                        del self._buf[:-len(self.HEADER) + 1 or None]
+                        continue
+
+                    # 2. 去掉头部的脏数据
+                    del self._buf[:idx]
+                    state = 'READ_LENGTH'
+                    need = self.HEADER_LEN
+                    continue
+
+                if state == 'READ_LENGTH':
+                    pkg_len = int.from_bytes(view[8:12], 'little')
+                    if pkg_len < self.HEADER_LEN or pkg_len > self.MAX_PKG_LEN:
+                        logger.warning(f"非法包长度 {pkg_len}，丢弃")
+                        del self._buf[:1]        # 跳过当前头继续找下一个
+                        state = 'FIND_HEADER'
+                        need = len(self.HEADER)
+                        continue
+
+                    state = 'READ_BODY'
+                    need = pkg_len
+                    continue
+
+                if state == 'READ_BODY':
+                    packet = bytes(view[:pkg_len])      # 拷贝一份完整包
+                    del self._buf[:pkg_len]             # 从缓冲区删除
+                    self._dispatch(packet)
+                    state = 'FIND_HEADER'
+                    need = len(self.HEADER)
+
+    # ---------- 业务分发 ----------
+    def _dispatch(self, packet: bytes) -> None:
+        try:
+            cmd = int.from_bytes(packet[12:14], 'little')
+            cls = CommandFactory.create_command(cmd)
+            inst = cls(self.device)
+            inst.parse_body(packet[self.HEADER_LEN:-2])  # 去掉头尾
+        except Exception as exc:
+            logger.exception(f"解析失败: {exc}")
+
+    # ---------- 工具 ----------
+    def set_device(self, device: IDevice) -> None:
+        self.device = device