qlsdk2 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

qlsdk/rsc/device/base.py

@@ -5,16 +5,21 @@ from time import sleep, time_ns
 from typing import Any, Dict, Literal
 
 from loguru import logger
+import numpy as np
+from qlsdk.core.entity import RscPacket
+from qlsdk.core.utils import to_bytes
 from qlsdk.persist import RscEDFHandler
 from qlsdk.rsc.interface import IDevice, IParser
 from qlsdk.rsc.parser import TcpMessageParser
 from qlsdk.rsc.command import StartImpedanceCommand, StopImpedanceCommand, StartStimulationCommand, StopStimulationCommand, SetAcquisitionParamCommand, StartAcquisitionCommand, StopAcquisitionCommand
-# from qlsdk.rsc.command import *
 
 class QLBaseDevice(IDevice):
     def __init__(self, socket):
         self.socket = socket
         
+        # 启动数据解析线程
+        self._parser: IParser = None
+        
         # 设备信息
         self.device_id = None
         self.device_name = None
@@ -113,26 +118,92 @@ class QLBaseDevice(IDevice):
         # 存储目录
         
         # 
-        self.__signal_consumer: Dict[str, Queue[Any]]={}
-        self.__impedance_consumer: Dict[str, Queue[Any]]={}
+        self._signal_consumer: Dict[str, Queue[Any]]={}
+        self._impedance_consumer: Dict[str, Queue[Any]]={}
         
         # EDF文件处理器
         self._edf_handler = None       
         self.storage_enable = True 
+        self._listening = False
+        # self.ready()
         
-        # 启动数据解析线程
-        self._parser: IParser = TcpMessageParser(self)
-        self._parser.start()
+    def parser(self) -> IParser:
+        return self._parser
+    
+    # 数据包处理
+    def produce(self, data: RscPacket):
+        if data is None: return     
         
-        # 启动数据接收线程
-        self._accept = Thread(target=self.accept)
-        self._accept.daemon = True
-        self._accept.start()
+        # 处理信号数据
+        self._signal_wrapper(data)   
+        
+        # 存储
+        if self.storage_enable:
+            self._write_signal(data)
+                        
+        if len(self.signal_consumers) > 0 :
+            # 信号数字值转物理值
+            data.eeg = self.eeg2phy(np.array(data.eeg))
+            
+            # 发送数据包到订阅者
+            for q in list(self.signal_consumers.values()):
+                q.put(data)
+                
+    # 信号数据转换(默认不处理)
+    def _signal_wrapper(self, data: RscPacket):
+        pass
+                
+    def _write_signal(self, data: RscPacket):
+        # 文件写入到edf
+        if self._edf_handler is None:
+            logger.debug("Initializing EDF handler for data storage")
+            self.init_edf_handler()
+        
+        if self._edf_handler:  
+            self._edf_handler.write(data)
+        
+    def start_listening(self):        
+        
+        try:
+            self.start_message_parser()
+            
+            self.start_message_listening()
+        except Exception as e:
+            logger.error(f"设备{self.device_no}准备失败: {str(e)}")
+            return False
+        
+        return True
+    
+    def stop_listening(self):
+        logger.trace(f"设备{self.device_no}停止socket监听")
+        self._listening = False
         
     @property
     def device_type(self) -> int:
         return self._device_type
     
+    def start_message_parser(self) -> None:
+        self._parser = TcpMessageParser(self)
+        self._parser.start()
+        logger.debug("TCP消息解析器已启动")
+    
+    def start_message_listening(self) -> None:
+        def _accept():
+            while self._listening:
+                # 缓冲区4M
+                data = self.socket.recv(4096*1024)
+                if not data:
+                    logger.warning(f"设备[{self.device_name}]连接结束")
+                    break
+                
+                self._parser.append(data)
+    
+        # 启动数据接收线程
+        self._listening = True
+        message_accept = Thread(target=_accept, daemon=True)
+        message_accept.start()
+        logger.debug(f"socket消息监听已启动")
+        
     def set_device_type(self, type: int):
         self._device_type = type
         
@@ -168,11 +239,13 @@ class QLBaseDevice(IDevice):
         return self._digital_range
     
     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_storage_path(self._storage_path)
-        self._edf_handler.set_file_prefix(self._file_prefix)
+        logger.warning("init_edf_handler not implemented in base class, should be overridden in subclass")
+        pass
+    #     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_no)
+    #     self._edf_handler.set_storage_path(self._storage_path)
+    #     self._edf_handler.set_file_prefix(self._file_prefix)
         
     # eeg数字值转物理值
     def eeg2phy(self, digital:int):
@@ -182,6 +255,7 @@ class QLBaseDevice(IDevice):
     @property
     def edf_handler(self):
         if not self.storage_enable:
+            logger.warning("EDF storage is disabled, no edf handler available")
             return None
         
         if self._edf_handler is None:
@@ -208,11 +282,11 @@ class QLBaseDevice(IDevice):
         return 10
     @property
     def signal_consumers(self):
-        return self.__signal_consumer
+        return self._signal_consumer
     
     @property
     def impedance_consumers(self):
-        return self.__impedance_consumer
+        return self._impedance_consumer
     
     # 设置记录文件路径
     def set_storage_path(self, path):
@@ -221,18 +295,6 @@ class QLBaseDevice(IDevice):
     # 设置记录文件名称前缀 
     def set_file_prefix(self, prefix):
         self._file_prefix = prefix
-        
-    # 接收socket消息
-    def accept(self):
-        while True:
-            # 缓冲去4M
-            data = self.socket.recv(4096*1024)
-            if not data:
-                logger.warning(f"设备{self.device_name}连接结束")
-                break
-            
-            self._parser.append(data)
-            
        
     # socket发送数据    
     def send(self, data):
@@ -256,26 +318,26 @@ class QLBaseDevice(IDevice):
         pass      
         
     def start_impedance(self):
-        logger.info("启动阻抗测量")  
+        logger.info(f"[设备-{self.device_no}]启动阻抗测量")  
         msg = StartImpedanceCommand.build(self).pack()
-        logger.debug(f"start_impedance message is {msg.hex()}")
+        logger.trace(f"start_impedance message is {msg.hex()}")
         self.socket.sendall(msg)
     
     def stop_impedance(self):
-        logger.info("停止阻抗测量")  
+        logger.info(f"[设备{self.device_no}]停止阻抗测量")  
         msg = StopImpedanceCommand.build(self).pack()
-        logger.debug(f"stop_impedance message is {msg.hex()}")
+        logger.trace(f"stop_impedance message is {msg.hex()}")
         self.socket.sendall(msg)
     
     def start_stimulation(self):
         if self.stim_paradigm is None:
             logger.warning("刺激参数未设置，请先设置刺激参数")
             return
-        logger.info("启动电刺激")  
+        logger.info(f"[设备-{self.device_no}]启动电刺激")  
         msg = StartStimulationCommand.build(self).pack()
-        logger.debug(f"start_stimulation message is {msg.hex()}")
+        logger.trace(f"start_stimulation message is {msg.hex()}")
         self.socket.sendall(msg)
-        t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,))
+        t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,), daemon=True)
         t.start()
         
     def _stop_stimulation_trigger(self, duration):
@@ -283,65 +345,74 @@ class QLBaseDevice(IDevice):
         while delay > 0:
             sleep(1)
             delay -= 1
-        logger.info(f"_stop_stimulation_trigger duration: {duration}")
+        logger.debug(f"_stop_stimulation_trigger duration: {duration}")
         if self._edf_handler:
             self._edf_handler.trigger("stimulation should be stopped")
         else:
             logger.warning("stop stim trigger fail. no edf writer alive")
         
     def stop_stimulation(self):
-        logger.info("停止电刺激")  
+        logger.info(f"[设备-{self.device_no}]停止电刺激")  
         msg = StopStimulationCommand.pack()
-        logger.debug(f"stop_stimulation message is {msg.hex()}")
+        logger.trace(f"stop_stimulation message is {msg.hex()}")
         self.socket.sendall(msg)
         
     # 启动采集
     def start_acquisition(self, recording = True):
-        logger.info("启动信号采集")  
+        logger.info(f"[设备-{self.device_no}]启动信号采集")  
         self._recording = recording
+        # 初始化EDF处理器
+        self.init_edf_handler()
         # 设置数据采集参数
         param_bytes = SetAcquisitionParamCommand.build(self).pack()
         # 启动数据采集
         start_bytes = StartAcquisitionCommand.build(self).pack()
         msg = param_bytes + start_bytes
-        logger.debug(f"start_acquisition message is {msg.hex()}")
+        logger.trace(f"start_acquisition message is {msg.hex()}")
         self.socket.sendall(msg)
         
     # 停止采集
     def stop_acquisition(self):
-        logger.info("停止信号采集")  
+        logger.info(f"[设备-{self.device_no}]停止信号采集")  
         msg = StopAcquisitionCommand.build(self).pack()
-        logger.debug(f"stop_acquisition message is {msg.hex()}")
+        logger.trace(f"stop_acquisition message is {msg.hex()}")
         self.socket.sendall(msg)
         if self._edf_handler:
             # 发送结束标识
             self.edf_handler.write(None)
         
-    # 订阅实时数据
+    '''
+        订阅数据
+        topic: 订阅主题
+        q: 数据队列
+        type: 数据类型，signal-信号数据，impedance-阻抗数据
+    '''
     def subscribe(self, topic:str=None, q : Queue=None, type : Literal["signal","impedance"]="signal"):  
             
+        # 队列名称     
+        if topic is None:
+            topic = f"{self.device_no}_{type}_{time_ns()}"
+            
+        logger.debug(f"[设备-{self.device_no}]订阅数据流： {topic}, type: {type}")    
+            
         # 数据队列
         if q is None:
             q = Queue(maxsize=1000)
-            
-        # 队列名称     
-        if topic is None:
-            topic = f"{type}_{time_ns()}"
         
         # 订阅生理电信号数据
         if type == "signal":
             # topic唯一，用来区分不同的订阅队列（下同）
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
+            if topic in list(self._signal_consumer.keys()):
+                logger.warning(f"已存在主题[{topic}]的信号数据订阅！")
             else:
-                self.__signal_consumer[topic] = q
+                self._signal_consumer[topic] = q
             
         # 订阅阻抗数据
         if type == "impedance":
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
+            if topic in list(self._impedance_consumer.keys()):
+                logger.warning(f"已存在主题[{topic}]的阻抗数据订阅！")
             else:
-                self.__impedance_consumer[topic] = q
+                self._impedance_consumer[topic] = q
             
         return topic, q
     
@@ -349,8 +420,19 @@ class QLBaseDevice(IDevice):
         if self._edf_handler:
             self.edf_handler.trigger(desc)
         else:
-            logger.warning("no edf handler, no place to recording trigger")
+            logger.warning("没有开启文件记录时，无法记录trigger信息")
+        
+    def gen_set_acquirement_param(self) -> bytes:
+        
+        body = to_bytes(self.acq_channels) 
+        body += self.sample_range.to_bytes(4, byteorder='little')
+        body += self.sample_rate.to_bytes(4, byteorder='little')
+        body += self.sample_num.to_bytes(4, byteorder='little')
+        body += self.resolution.to_bytes(1, byteorder='little')
+        body += bytes.fromhex('00')     
         
+        return body
+    
     def __str__(self):
         return f''' 
             Device: 
@@ -366,21 +448,6 @@ class QLBaseDevice(IDevice):
                 Battery Total: {str(self.battery_total) + "%" if self.battery_total else None}
             '''
 
-    def __repr__(self):
-        return f''' 
-            Device: 
-                Name: {self.device_name}, 
-                Type: {hex(self.device_type)}, 
-                ID: {self.device_id}, 
-                Software: {self.software_version}, 
-                Hardware: {self.hardware_version}, 
-                Connect Time: {self.connect_time},
-                Current Time: {self.current_time},
-                Voltage: {self.voltage}mV,
-                Battery Remain: {self.battery_remain}%,
-                Battery Total: {self.battery_total}%
-            '''
-
     def __eq__(self, other):
         return self.device_name == other.device_name and self.device_type == other.device_type and self.device_id == other.device_id
 

qlsdk/rsc/device/c16_rs.py

@@ -0,0 +1,205 @@
+
+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
+        }
+        
+        # self.channel_mapping = {
+        #     "1": 61, 
+        #     "2": 62, 
+        #     "3": 63, 
+        #     "4": 64, 
+        #     "5": 65, 
+        #     "6": 66, 
+        #     "7": 68, 
+        #     "8": 67,
+        #     "9": 53, 
+        #     "10": 54, 
+        #     "11": 55, 
+        #     "12": 57, 
+        #     "13": 59, 
+        #     "14": 58, 
+        #     "15": 60, 
+        #     "16": 56, 
+        #     "17": 26, 
+        #     "18": 25, 
+        #     "19": 24, 
+        #     "20": 23, 
+        #     "21": 22
+        # }        
+        
+        self.channel_mapping = {
+            "1": 2, 
+            "2": 3, 
+            "3": 27, 
+            "4": 31, 
+            "5": 60, 
+            "6": 61, 
+            "7": 25, 
+            "8": 29,
+            "9": 33, 
+            "10": 62, 
+            "11": 63, 
+            "12": 10, 
+            "13": 14, 
+            "14": 8, 
+            "15": 12, 
+            "16": 16, 
+            "17": 43, 
+            "18": 45, 
+            "19": 47, 
+            "20": 49, 
+            "21": 51
+        }
+        
+        self.channel_display_mapping = {
+            2: 1, 
+            3: 2, 
+            27: 3, 
+            31: 4, 
+            60: 5, 
+            61: 6, 
+            25: 7, 
+            29: 8,
+            33: 9, 
+            62: 10, 
+            63: 11, 
+            10: 12, 
+            14: 13, 
+            8: 14, 
+            12: 15, 
+            16: 16, 
+            43: 17, 
+            45: 18, 
+            47: 19, 
+            49: 20, 
+            51: 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)  
+        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) 
+    
+