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

qlsdk/rsc/device/arskindling.py

@@ -1,133 +1,55 @@
-
 from multiprocessing import Queue
-from threading import Thread
-from time import sleep, time_ns
-from typing import Any, Dict, Literal
-
+from typing import Literal
 from loguru import logger
 from qlsdk.persist import ARSKindlingEDFHandler
-from qlsdk.rsc.interface import IDevice, IParser
+from qlsdk.rsc.interface import IDevice
 from qlsdk.rsc.command import *
-from qlsdk.rsc.parser.base import TcpMessageParser
 from qlsdk.rsc.device.base import QLBaseDevice
 
+    
+def intersection_positions(A, B):
+    setB = set(B)
+    seen = set()
+    return [idx for idx, elem in enumerate(A) 
+            if elem in setB and elem not in seen and not seen.add(elem)]
+ 
+def get_sorted_indices_basic(A, B):
+    """
+    找出数组A中存在于数组B的元素，并返回这些元素在A中的位置，且顺序与它们在B中的顺序一致。
+
+    参数:
+        A (list): 待查找的数组。
+        B (list): 作为参考的数组。
+
+    返回:
+        list: 一个列表，包含符合条件的元素在A中的索引，顺序与这些元素在B中的出现顺序一致。
+    """
+    # 1. 创建B中元素到其索引的映射
+    b_index_map = {value: idx for idx, value in enumerate(B)}
+    
+    # 2. 筛选A中存在于B的元素，并记录其在A中的索引及在B中的位置
+    # 使用列表推导式，同时避免重复元素干扰（如果B有重复，以第一次出现为准）
+    found_elements = []
+    for idx_a, value in enumerate(A):
+        if value in b_index_map:
+            # 记录: (该元素在A中的索引, 该元素在B中的索引)
+            found_elements.append((idx_a, b_index_map[value]))
+    
+    # 3. 根据元素在B中的位置进行排序
+    # 排序的依据是元组的第二个元素，即 b_index_map[value]
+    found_elements_sorted = sorted(found_elements, key=lambda x: x[1])
+    
+    # 4. 提取排序后在A中的索引，形成结果数组C
+    array_C = [item[0] for item in found_elements_sorted]
+    
+    return array_C
+   
 class ARSKindling(QLBaseDevice):
     
     device_type = 0x60 # C64RS设备类型标识符
     
     def __init__(self, socket):
         super().__init__(socket)
-        # self.socket = socket
-        
-        self._id = None
-        
-        # 设备信息
-        # self.device_id = None
-        # self.device_name = None
-        self._device_no = None
-        # self.software_version = None
-        # self.hardware_version = None
-        # self.connect_time = None
-        # self.current_time = None
-        # # mV
-        # self.voltage = None
-        # # %
-        # self.battery_remain = None
-        # # %
-        # self.battery_total = None
-        # persist
-        self._recording = False
-        self._storage_path = None
-        self._file_prefix = None
-        
-        # 可设置参数
-        # 采集：采样量程、采样率、采样通道
-        # 刺激：刺激电流、刺激频率、刺激时间、刺激通道
-        # 采样量程（mV）：188、375、563、750、1125、2250、4500
-        self._sample_range:Literal[188, 375, 563, 750, 1125, 2250, 4500] = 188        
-        # 采样率（Hz）：250、500、1000、2000、4000、8000、16000、32000
-        self._sample_rate:Literal[250, 500, 1000, 2000, 4000, 8000, 16000, 32000] = 500
-        self._physical_max = self._sample_range * 1000  # 物理最大值（uV）
-        self._physical_min = -self._sample_range * 1000  # 物理最小值（uV）
-        self._digital_max = 8388607
-        self._digital_min = -8388608
-        self._physical_range = self._physical_max - self._physical_min
-        self._digital_range = 16777215
-        self._acq_channels = None
-        self._acq_param = {
-            "sample_range": 188,
-            "sample_rate": 500,
-            "channels": [],
-        }
-        
-        self._stim_param = {
-            "stim_type": 0,                 # 刺激类型：0-所有通道参数相同, 1: 通道参数不同
-            "channels": [],
-            "param": [{
-                    "channel_id": 0,        #通道号 从0开始                          -- 必填
-                    "waveform": 3,          #波形类型：0-直流，1-交流 2-方波 3-脉冲   -- 必填
-                    "current": 1,           #电流强度(mA)                            -- 必填
-                    "duration": 30,         #平稳阶段持续时间(s)                      -- 必填
-                    "ramp_up": 5,           #上升时间(s) 默认0
-                    "ramp_down": 5,         #下降时间(s) 默认0
-                    "frequency": 500,       #频率(Hz) -- 非直流必填
-                    "phase_position": 0,    #相位 -- 默认0
-                    "duration_delay": "0",  #延迟启动时间(s) -- 默认0
-                    "pulse_width": 0,       #脉冲宽度(us) -- 仅脉冲类型电流有效， 默认100us
-                },
-                {
-                    "channel_id": 1,        #通道号 从0开始                          -- 必填
-                    "waveform": 3,          #波形类型：0-直流，1-交流 2-方波 3-脉冲   -- 必填
-                    "current": 1,           #电流强度(mA)                            -- 必填
-                    "duration": 30,         #平稳阶段持续时间(s)                      -- 必填
-                    "ramp_up": 5,           #上升时间(s) 默认0
-                    "ramp_down": 5,         #下降时间(s) 默认0
-                    "frequency": 500,       #频率(Hz) -- 非直流必填
-                    "phase_position": 0,    #相位 -- 默认0
-                    "duration_delay": "0",  #延迟启动时间(s) -- 默认0
-                    "pulse_width": 0,       #脉冲宽度(us) -- 仅脉冲类型电流有效， 默认100us
-                }
-            ]
-        }
-        
-        self.stim_paradigm = None
-                      
-        signal_info = {
-            "param" : None,
-            "start_time" : None,
-            "finished_time" : None,
-            "packet_total" : None,
-            "last_packet_time" : None,
-            "state" : 0
-        }
-        stim_info = {
-            
-        }
-        Impedance_info = {
-            
-        }
-        # 信号采集状态
-        # 信号数据包总数（一个信号采集周期内）
-        # 信号采集参数
-        # 电刺激状态
-        # 电刺激开始时间（最近一次）
-        # 电刺激结束时间（最近一次）
-        # 电刺激参数
-        # 启动数据解析线程
-        # 数据存储状态
-        # 存储目录
-        
-        # 
-        self.__signal_consumer: Dict[str, Queue[Any]]={}
-        self.__impedance_consumer: Dict[str, Queue[Any]]={}
-        
-        # EDF文件处理器
-        self._edf_handler = None       
-        self.storage_enable = True 
-        
-        # self.start_message_listening()
-        # self.start()
-        # self.parser.set_device(self)
         
         self.channel_mapping = {
             "A1": 55, "A2": 56, "A3": 53, "A4": 54, "A5": 51, "A6": 52, "A7": 49, "A8": 50,
@@ -143,18 +65,75 @@ class ARSKindling(QLBaseDevice):
             "D9": 9, "D10": 10, "D11": 11, "D12": 12, "D13": 13, "D14": 14, 
         }
         
-    @property
-    def device_no(self):
-        return self._device_no
-    
-    @device_no.setter
-    def device_no(self, value: str):
-        self._device_no = value
-    
-    @property
-    def parser(self) -> IParser:
-        return self._parser
-    
+        self._channel_spilt = {
+            "A" : [55, 56, 53, 54, 51, 52, 49, 50, 57, 58, 59, 60, 61, 62],
+            "B" : [39, 40, 37, 38, 35, 36, 33, 34, 41, 42, 43, 44, 45, 46],
+            "C" : [23, 24, 21, 22, 19, 20, 17, 18, 25, 26, 27, 28, 29, 30],
+            "D" : [7, 8, 5, 6, 3, 4, 1, 2, 9, 10, 11, 12, 13, 14],
+        }
+        
+        self._channel_mapping = {
+            1: "7", 
+            2: "8",
+            3: "5", 
+            4: "6",
+            5: "3", 
+            6: "4",
+            7: "1", 
+            8: "2",
+            9: "9", 
+            10: "10",
+            11: "11", 
+            12: "12",
+            13: "13", 
+            14: "14",
+            
+            17: "7", 
+            18: "8",
+            19: "5", 
+            20: "6",
+            21: "3", 
+            22: "4",
+            23: "1", 
+            24: "2",
+            25: "9", 
+            26: "10",
+            27: "11", 
+            28: "12",
+            29: "13", 
+            30: "14",
+            
+            33: "7", 
+            34: "8",
+            35: "5", 
+            36: "6",
+            37: "3", 
+            38: "4",
+            39: "1", 
+            40: "2",
+            41: "9", 
+            42: "10",
+            43: "11", 
+            44: "12",
+            45: "13", 
+            46: "14",
+            
+            49: "7", 
+            50: "8",
+            51: "5", 
+            52: "6",
+            53: "3", 
+            54: "4",
+            55: "1", 
+            56: "2",
+            57: "9", 
+            58: "10",
+            59: "11", 
+            60: "12",
+            61: "13", 
+            62: "14"
+        }
+                
     @classmethod
     def from_parent(cls, parent:IDevice) -> IDevice:
         rlt = cls(parent.socket)
@@ -168,68 +147,8 @@ class ARSKindling(QLBaseDevice):
         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 'ARS')
+        logger.debug(f"EDF Handler initialized")
         
-    @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):
-        if self._acq_channels is None:
-            self._acq_channels = [i for i in range(1, 63)]
-        return self._acq_channels
-    @property
-    def sample_range(self):
-        return self._sample_range if self._sample_range else 188
-    @property
-    def sample_rate(self):
-        return self._sample_rate if self._sample_rate else 500
-    @property
-    def resolution(self):
-        return 24
-    
-    @property
-    def signal_consumers(self):
-        return self.__signal_consumer
-    
-    @property
-    def impedance_consumers(self):
-        return self.__impedance_consumer
-    
-    # 设置记录文件路径
-    def set_storage_path(self, path):
-        self._storage_path = path
-       
-    # 设置记录文件名称前缀 
-    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_no}连接结束")
-                break
-            
-            self._parser.append(data)
-            
-       
-    # socket发送数据    
-    def send(self, data):
-        self.socket.sendall(data)
-    
-    # 设置刺激参数
-    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
@@ -249,138 +168,157 @@ class ARSKindling(QLBaseDevice):
         self._acq_param["sample_range"] = sample_range
         self._acq_channels = channels
         self._sample_rate = sample_rate
-        self._sample_range = sample_range
+        self._sample_range = sample_range     
     
-    # 通用配置-TODO
-    def set_config(self, key:str, val: str):
-        pass      
+    # 设置阻抗通道
+    # {'A': [1,2,3], 'B':[1,2,3]}
+    def set_impedance_channels(self, channels):
         
-    def start_impedance(self):
-        logger.info("启动阻抗测量")  
-        msg = StartImpedanceCommand.build(self).pack()
-        logger.debug(f"start_impedance message is {msg.hex()}")
-        self.socket.sendall(msg)
-    
-    def stop_impedance(self):
-        logger.info("停止阻抗测量")  
-        msg = StopImpedanceCommand.build(self).pack()
-        logger.debug(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("启动电刺激")  
-        msg = StartStimulationCommand.build(self).pack()
-        logger.debug(f"start_stimulation message is {msg.hex()}")
-        self.socket.sendall(msg)
-        t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,))
-        t.start()
+        arr = []
         
-    def _stop_stimulation_trigger(self, duration):
-        delay = duration
-        while delay > 0:
-            sleep(1)
-            delay -= 1
-        logger.info(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")
+        # 根据映射关系做通道转换
+        for k in channels.keys():
+            if isinstance(channels[k], list):
+                temp = [k + str(i) for i in channels[k]]
+                arr += [self.channel_mapping.get(c, 1) for c in temp]
+            else:
+                arr += [k + str(channels[k])]
+                
+        self._impedance_channels = arr
         
-    def stop_stimulation(self):
-        logger.info("停止电刺激")  
-        msg = StopStimulationCommand.pack()
-        logger.debug(f"stop_stimulation message is {msg.hex()}")
-        self.socket.sendall(msg)
+    @property
+    def acq_channels(self):
+        if self._acq_channels is None:
+            self._acq_channels = [i for i in range(1, 63)]
+            
+        arr = []
+        for k in self._acq_channels.keys():
+            arr = list(arr + self._acq_channels[k])
+            
+        return list(set(arr))    
+    
+    def _produce_impedance(self, body: bytes):
+        # 分发阻抗数据包给订阅者
+        if len(self._impedance_consumer) > 0:
+            packet = self._impedance_wrapper(body)
+            real_data = self.__impedance_transfer(packet)
+            for topic, q in self._impedance_consumer.items():
+                try:
+                    # 队列满了就丢弃最早的数据
+                    if q.full(): 
+                        q.get()
+                    q.put(real_data, timeout=1)
+                except Exception as e:
+                    logger.error(f"impedance data put to queue exception: {str(e)}")
+                    
+    def _produce_signal(self, body: bytes):        
         
-    # 启动采集
-    def start_acquisition(self, recording = True):
-        logger.info("启动信号采集")  
-        self._recording = recording
-        # 设置数据采集参数
-        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()}")
-        self.socket.sendall(msg)
+        # 处理信号数据
+        data = self._signal_wrapper(body)  
+        # logger.debug("pkg_id: {}, eeg len: {}".format(data.pkg_id, len(data.eeg)))
         
-    # 停止采集
-    def stop_acquisition(self):
-        logger.info("停止信号采集")  
-        msg = StopAcquisitionCommand.build(self).pack()
-        logger.debug(f"stop_acquisition message is {msg.hex()}")
-        self.socket.sendall(msg)
-        if self._edf_handler:
-            # 发送结束标识
-            self.edf_handler.write(None)
+        trigger_positions = [index for index, value in enumerate(data.trigger) if value != 0]
+        if len(trigger_positions) > 0:
+            # logger.debug(f"Trigger触发点位置: {trigger_positions}, 触发点时间戳: {[data.time_stamp + int(pos * 1000 / data.sample_rate) for pos in trigger_positions]}")
+            for pos in trigger_positions:
+                self.trigger(self.trigger_info(data.trigger[pos]))
         
-    # 订阅实时数据
-    def subscribe(self, topic:str=None, q : Queue=None, type : Literal["signal","impedance"]="signal"):  
-        logger.info(f"订阅{self.device_no}的数据流")    
-        # 数据队列
-        if q is None:
-            q = Queue(maxsize=1000)
-            
-        # 队列名称     
-        if topic is None:
-            topic = f"{type}_{time_ns()}"
+        if len(self.signal_consumers) > 0 :
+            # 信号数字值转物理值
+            data.eeg_p = self.eeg2phy(np.array(data.eeg))        
         
-        # 订阅生理电信号数据
-        if type == "signal":
-            # topic唯一，用来区分不同的订阅队列（下同）
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
-            else:
-                self.__signal_consumer[topic] = q
+        real_data = self.__signal_transfer(data)   
+               
+        # 存储
+        if self.storage_enable:            
+            # 确保记录线程启动
+            if self._recording is False:
+                self._start_recording() 
+                
+            # 写入文件的缓存队列
+            if self._signal_cache is None:
+                self._signal_cache = Queue(1000000)  # 缓冲队列
+            tmp = real_data.copy()
+            self._signal_cache.put(tmp)
+                                    
+        if len(self.signal_consumers) > 0 :
+            # 订阅只返回物理值
+            real_data.eeg = real_data.eeg_p
+            # 发送数据包到订阅者
+            for q in list(self.signal_consumers.values()):
+                # 队列满了就丢弃最早的数据
+                if q.full(): 
+                    q.get()
+                    
+                q.put(real_data)      
+     
+    # 信号数据转换
+    def __impedance_transfer(self, packet: ImpedancePacket):
+        channels = {}
+        impedance = {}
+        #按分区拆分数据格式
+        for k in self._channel_spilt.keys():      
+            logger.trace(f'分区{k}的阻抗数据')   
+            c, d, p = self.__packet_filter(packet, self._channel_spilt[k], type='impedance')
+            if c is not None:
+                channels[k] = c
+                impedance[k] = d
+        packet.channels = channels
+        packet.impedance = impedance
             
-        # 订阅阻抗数据
-        if type == "impedance":
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
-            else:
-                self.__impedance_consumer[topic] = q
+        return packet
+      
+    # 信号数据转换
+    def __signal_transfer(self, packet: RscPacket):
+        channels = {}
+        eeg = {}
+        eeg_p = {}
+        #按分区拆分数据格式
+        for k in self._channel_spilt.keys():      
+            logger.trace(f'分区{k}, {self._channel_spilt[k]}')   
+            c, d, p = self.__packet_filter(packet, self._channel_spilt[k])
+            if c is not None:
+                channels[k] = c
+                eeg[k] = d
+            if p is not None:
+                eeg_p[k] = p
+        packet.channels = channels
+        packet.eeg = eeg
+        #物理值
+        if packet.eeg_p is not None:
+            packet.eeg_p = eeg_p
             
-        return topic, q
+        return packet
     
-    def trigger(self, desc):
-        if self._edf_handler:
-            self.edf_handler.trigger(desc)
-        else:
-            logger.warning("no edf handler, no place to recording trigger")
+    def __packet_filter(self, packet, channel_filter=None, type:Literal['signal','impedance']='signal'):
+        # 参数检查
+        if packet is None or channel_filter is None:
+            logger.warning("空数据，忽略")
+            return None, None, None
         
-    
-    def gen_set_acquirement_param(self) -> bytes:
+        channel_pos = get_sorted_indices_basic(packet.channels, channel_filter)
         
-        arr = []
-        for k in self.acq_channels.keys():
-            arr = list(arr + self.acq_channels[k])
-            
-        arr = list(set(arr))
-        body = to_bytes(arr) 
-        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')     
+        if channel_pos is None or len(channel_pos) == 0 :
+            logger.trace(f"没有指定分区的通道，跳过")
+            return None, None, None
+        
+        # 分区数据包写入
+        
+        # 保留本分区的通道和数据
+        channels = [packet.channels[p] for p in channel_pos]
+        
+        #阻抗数据
+        if type == 'impedance':
+            impedance = [packet.impedance[p] for p in channel_pos]
+            return [self._channel_mapping.get(channel_id, []) for channel_id in channels], impedance, None
+        
+        # 信号数据
+        eeg = [packet.eeg[p] for p in channel_pos]
+        eeg_p = None
+        if packet.eeg_p is not None:
+            eeg_p = [packet.eeg_p[p] for p in channel_pos]
+        
+        return [self._channel_mapping.get(channel_id, []) for channel_id in channels], eeg, eeg_p
         
-        return body
-    
-    def __str__(self):
-        return f''' 
-            Device: 
-                Name: {self.device_no}, 
-                Type: {hex(self.device_type) if self.device_type else None}, 
-                ID: {self.device_id if self.device_id else None}, 
-                Software: {self.software_version}, 
-                Hardware: {self.hardware_version}, 
-                Connect Time: {self.connect_time},
-                Current Time: {self.current_time},
-                Voltage: {str(self.voltage) + "mV" if self.voltage else None},
-                Battery Remain: {str(self.battery_remain)+ "%" if self.battery_remain else None},
-                Battery Total: {str(self.battery_total) + "%" if self.battery_total else None}
-            '''