qlsdk2 0.6.0a13__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

qlsdk/core/entity/__init__.py

@@ -54,6 +54,22 @@ class RscPacket(Packet):
         logger.trace(packet)
         
         return packet
+
+    def copy(self) -> 'RscPacket':
+        packet = RscPacket()
+        packet.time_stamp = self.time_stamp
+        packet.pkg_id = self.pkg_id
+        packet.result = self.result
+        packet.channels = self.channels
+        packet.origin_sample_rate = self.origin_sample_rate
+        packet.sample_rate = self.sample_rate
+        packet.sample_num = self.sample_num
+        packet.resolution = self.resolution
+        packet.filter = self.filter
+        packet.data_len = self.data_len
+        packet.trigger = self.trigger
+        packet.eeg = self.eeg
+        return packet  
         
     def __str__(self):
         return f"""[

qlsdk/persist/rsc_edf.py

@@ -131,7 +131,7 @@ class EDFStreamWriter(Thread):
         logger.trace(f"sf: {self.sample_frequency}, pm: {self.physical_max}, pn: {self.physical_min}, dm: {self.digital_max}, dn: {self.digital_min}")
         for ch in range(self._n_channels):
             signal_headers.append({
-                "label": f'channels {self._channels[ch]}',
+                "label": f'channel {self._channels[ch]}',
                 "dimension": 'uV',
                 "sample_frequency": self.sample_frequency,
                 "physical_min": self.physical_min,
@@ -296,6 +296,8 @@ class RscEDFHandler(object):
             logger.info(f"收到结束信号，即将停止写入数据:{self.file_name}")
             self._edf_writer_thread.stop_recording()
             return
+        
+        logger.debug(f"packet: {packet}")
     
         with self._lock:
             if self.channels is None:

qlsdk/rsc/command/__init__.py

@@ -6,7 +6,6 @@ from loguru import logger
 
 
 from qlsdk.core.crc import crc16
-from qlsdk.core.entity import RscPacket, ImpedancePacket
 from qlsdk.core.utils import to_channels, to_bytes
 from qlsdk.rsc.interface import IDevice
 
@@ -57,6 +56,7 @@ class DeviceCommand(abc.ABC):
         if device_type > 0xFF:
             b_device_type = int.to_bytes(device_type, 2, 'little')
         
+        packet_len = DeviceCommand.HEADER_LEN + body_len + 2
         if b_device_type is None:
             return (
                 DeviceCommand.HEADER_PREFIX
@@ -69,10 +69,11 @@ class DeviceCommand(abc.ABC):
         else:
             return (
                 DeviceCommand.HEADER_PREFIX
-                + b_device_type[0].to_bytes(1, 'little')     # pkgType  
                 + b_device_type[1].to_bytes(1, 'little')
-                + device_id.to_bytes(4, 'little')
-                + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
+                + b_device_type[0].to_bytes(1, 'little')     # pkgType  
+                # + device_id.to_bytes(4, 'little')
+                + device_id
+                + packet_len.to_bytes(4, 'little')  # +1 for checksum
                 + self.cmd_code.to_bytes(2, 'little')
             )
     

qlsdk/rsc/device/__init__.py

@@ -5,4 +5,8 @@ from .device_factory import DeviceFactory
 from .c64_rs import C64RS
 from .c16_rs import C16RS
 from .arskindling import ARSKindling
-from .c256_rs import C256RS
+from .c256_rs import C256RS
+from .c8r import C8R
+from .c16r import C16R
+from .c21r import C21R
+from .c64s1 import C64S1

qlsdk/rsc/device/arskindling.py

@@ -1,6 +1,7 @@
 from multiprocessing import Queue
 from typing import Literal
 from loguru import logger
+from qlsdk.core.entity import ImpedancePacket, RscPacket
 from qlsdk.persist import ARSKindlingEDFHandler
 from qlsdk.rsc.interface import IDevice
 from qlsdk.rsc.command import *
@@ -238,7 +239,7 @@ class ARSKindling(QLBaseDevice):
             # 写入文件的缓存队列
             if self._signal_cache is None:
                 self._signal_cache = Queue(1000000)  # 缓冲队列
-            tmp = real_data
+            tmp = real_data.copy()
             self._signal_cache.put(tmp)
                                     
         if len(self.signal_consumers) > 0 :

qlsdk/rsc/device/base.py

@@ -139,6 +139,10 @@ class QLBaseDevice(IDevice):
         
         # 处理信号数据
         data = self._signal_wrapper(body)  
+        
+        if data is None:
+            logger.warning("signal data is None")
+            return
         # logger.debug("pkg_id: {}, eeg len: {}".format(data.pkg_id, len(data.eeg)))
         # 
         trigger_positions = [index for index, value in enumerate(data.trigger) if value != 0]
@@ -155,7 +159,7 @@ class QLBaseDevice(IDevice):
             # 写入文件的缓存队列
             if self._signal_cache is None:
                 self._signal_cache = Queue(256 * 1024 * 1024)  # 256MB缓存
-            tmp = data
+            tmp = data.copy()
             self._signal_cache.put(tmp)
                                     
         if len(self.signal_consumers) > 0 :
@@ -173,10 +177,11 @@ class QLBaseDevice(IDevice):
                 q.put(data)    
                 
     def _impedance_wrapper(self, body: bytes):        
-        packet = ImpedancePacket().transfer(body)    
-        if self._impedance_channels is not None and len(self._impedance_channels) > 0:
+        packet = ImpedancePacket().transfer(body)   
+        impedance_channels = self.get_impedance_channels() 
+        if impedance_channels is not None and len(impedance_channels) > 0:
             # 只保留设置的阻抗通道
-            channel_pos = intersection_positions(packet.channels, self._impedance_channels)
+            channel_pos = intersection_positions(packet.channels, impedance_channels)
             packet.impedance = [packet.impedance[i] for i in channel_pos]
             packet.channels = [packet.channels[i] for i in channel_pos]
             
@@ -258,6 +263,8 @@ class QLBaseDevice(IDevice):
         self._impedance_channels = channels
         
     def get_impedance_channels(self): 
+        if self._impedance_channels is None or len(self._impedance_channels) == 0:
+            self._impedance_channels = [i for i in range(1, 63)]
         return self._impedance_channels    
     
     def start_message_parser(self) -> None:
@@ -396,15 +403,13 @@ class QLBaseDevice(IDevice):
     def start_impedance(self):
         logger.info(f"[设备-{self.device_no}]启动阻抗测量")  
         # 设置数据采集参数
-        # set_param_msg = SetImpedanceParamCommand.build(self).pack()
-        device_id = bytes.fromhex(self.device_id)[::-1].hex() if self.device_id else '00000000'
-        set_param_msg = bytes.fromhex(f'5aa50239{device_id}3f0000001104ffffffffffffffff000000000000000000000000000000000000000000000000e8030000fa00000010000164000000745c5aa50239390045243a00000012040000000000000000000000000000000000000000000000000000000000000000000001000000000000004c2a')
-        logger.debug(f"set_param_msg message is {set_param_msg.hex()}")
+        set_param_msg = SetImpedanceParamCommand.build(self).pack()
+        # logger.debug(f"set_param_msg message is {set_param_msg.hex()}")
         self.socket.sendall(set_param_msg)
         sleep(0.5)
     
         impedance_start_msg = StartImpedanceCommand.build(self).pack()
-        logger.debug(f"start_impedance message is {impedance_start_msg.hex()}")
+        # logger.debug(f"start_impedance message is {impedance_start_msg.hex()}")
         self.socket.sendall(impedance_start_msg)
     
     def stop_impedance(self):
@@ -524,15 +529,17 @@ class QLBaseDevice(IDevice):
     def gen_set_impedance_param(self) -> bytes:
         
         # 仅通道生效 32字节，其他不生效-272字节，实际73字节
-        body = to_bytes(self._impedance_channels) 
-        # 100 bytes
-        # body += bytes.fromhex('00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')     
-        # # 100 bytes
-        # body += bytes.fromhex('00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')     
-        # 73 bytes
-        body += bytes.fromhex('00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')     
-        
-        return bytes.fromhex('ffffffffffffffff000000000000000000000000000000000000000000000000e8030000fa00000010000164000000745c5aa50239390045243a0000001204000000000000000000000000000000000000000000000000000000000000000000000100000000000000')
+        # body = to_bytes(self._impedance_channels) 
+        # 阻抗参数设置当前是固定长度3f000000, 通道全部指定ffffffffffffffff
+        body = bytes.fromhex('ffffffffffffffff')
+        # 测量类型-正弦波  不生效 放15字节的0
+        body += bytes.fromhex('000000000000000000000000000000')
+        # 测量频率-1000Hz  不生效
+        # freq = 1000
+        # body += freq.to_bytes(4, byteorder='little')# 24 bytes
+        body += bytes.fromhex('000000000000000000000000000000000000000000000000')
+        
+        return body
     def disconnect(self):
         logger.info(f"[断开设备-{self.device_no}]的连接...")  
         self._listening = False

qlsdk/rsc/device/c16_rs.py

@@ -5,6 +5,7 @@ from time import sleep, time_ns
 from typing import Any, Dict, Literal
 
 from loguru import logger
+from qlsdk.core.entity import RscPacket
 from qlsdk.persist import RscEDFHandler
 from qlsdk.rsc.device.device_factory import DeviceFactory
 from qlsdk.rsc.interface import IDevice
@@ -17,7 +18,7 @@ from qlsdk.rsc.device.base import QLBaseDevice
 '''
 class C16RS(QLBaseDevice):
     
-    device_type = 0x339  # C16RS设备类型标识符
+    device_type = 0x439  # C16RS设备类型标识符  0x3904
     
     def __init__(self, socket):
         

qlsdk/rsc/device/c16r.py

@@ -0,0 +1,203 @@
+from loguru import logger
+from qlsdk.core.entity import ImpedancePacket, RscPacket
+from qlsdk.persist import RscEDFHandler
+from qlsdk.rsc.device.base import QLBaseDevice, intersection_positions
+from qlsdk.rsc.device.device_factory import DeviceFactory
+from qlsdk.rsc.interface import IDevice
+from qlsdk.rsc.device.base import QLBaseDevice
+
+class C16R(QLBaseDevice):
+    
+    device_type = 0x339  # C16R设备类型标识符 0x3903
+    
+    def __init__(self, socket):
+        super().__init__(socket)
+    
+        # 存储通道反向映射位置值
+        self._reverse_ch_pos  = None    
+        
+        # 存储通道反向映射位置值
+        self._impedance_ch_pos  = None    
+        self._impedance_channels_origin = None
+        
+        self.channel_name_mapping = {
+            "FP1": 1, 
+            "FP2": 2, 
+            "F7": 3, 
+            "F8": 4, 
+            "P3": 5, 
+            "P4": 6, 
+            "O1": 7, 
+            "O2": 8, 
+            "CZ": 9, 
+            "A1": 10, 
+            "A2": 11, 
+        }
+        
+        self.channel_mapping = {
+            "1": 59, 
+            "2": 60, 
+            "3": 53, 
+            "4": 50, 
+            "5": 63, 
+            "6": 24, 
+            "7": 51, 
+            "8": 64,
+            "9": 49, 
+            "10": 14, 
+            "11": 10, 
+        }
+        
+        self.channel_display_mapping = {
+            59: 1, 
+            60: 2, 
+            53: 3, 
+            50: 4, 
+            63: 5, 
+            24: 6, 
+            51: 7, 
+            64: 8,
+            49: 9, 
+            14: 10, 
+            10: 11, 
+        }
+        
+    @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 'C8R')
+        logger.debug(f"EDF Handler initialized")
+        # 设置采集参数
+    def set_acq_param(self, channels:list, sample_rate: int = 500, sample_range:int = 188):
+        # 通道合法性校验
+        self._channel_validate(channels)
+        # 保存原始通道参数
+        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  
+    
+    @property
+    def acq_channels(self):
+        if self._acq_channels is None:
+            # 初始化通道参数为1-11
+            self.set_acq_param([i for i in range(1, 12)])
+        return self._acq_channels  
+    
+    def set_impedance_channels(self, channels:list):
+        # 通道合法性校验
+        self._channel_validate(channels)
+        # 保存原始通道参数
+        self._impedance_channels_origin = 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._impedance_channels = channels
+        
+        # 初始化位置映射
+        self._impedance_ch_pos  = None  
+        
+    def get_impedance_channels(self): 
+        if self._impedance_channels is None or len(self._impedance_channels) == 0:
+            self.set_impedance_channels([i for i in range(1, 12)])
+        return self._impedance_channels   
+    
+    def _channel_validate(self, channels: list):
+        # 名称转换为数字通道  
+        temp_channels = [self.channel_name_mapping.get(str(i).upper(), i) for i in channels]
+        
+        # 根据映射关系做通道转换-没有映射的默认到第一个通道
+        # 先设置不存在的通道为-1，再把-1替换为第一个通道，避免第一个通道也不合法的情况
+        temp_channels = [self.channel_mapping.get(str(i), -1) for i in temp_channels]
+        for i in range(len(temp_channels)):
+            if temp_channels[i] == -1:
+                raise ValueError(f"通道参数有误，通道应为1-11的数字或对应名称，如：1、2或FP1、FP2等")
+    
+    def _impedance_wrapper(self, body: bytes):        
+        packet = ImpedancePacket().transfer(body)   
+        impedance_channels = self.get_impedance_channels() 
+        if impedance_channels is not None and len(impedance_channels) > 0:
+            # 只保留设置的阻抗通道
+            channel_pos = intersection_positions(packet.channels, impedance_channels)
+            packet.impedance = [packet.impedance[i] for i in channel_pos]
+            packet.channels = [packet.channels[i] for i in channel_pos]
+            
+        # 升级为类变量，减少计算
+        if self._impedance_ch_pos is None:
+            self._impedance_ch_pos = map_indices(impedance_channels, packet.channels)
+            
+        packet.channels = self._impedance_channels_origin
+        packet.impedance = [packet.impedance[i] for i in self._impedance_ch_pos]
+            
+        return packet
+    
+    # 信号数据转换(默认不处理)
+    def _signal_wrapper(self, body: bytes):
+        if body is None:
+            return
+        data = RscPacket().transfer(body)
+        # 根据映射关系做通道转换-（注意数据和通道的一致性）
+        # 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]
+        
+        return data
+        
+    def start_stimulation(self):
+        raise NotImplementedError("Stimulation function is not supported")
+        
+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]
+
+DeviceFactory.register(C16R.device_type, C16R) 

qlsdk/rsc/device/c21r.py

@@ -0,0 +1,239 @@
+from loguru import logger
+from qlsdk.core.entity import ImpedancePacket, RscPacket
+from qlsdk.persist import RscEDFHandler
+from qlsdk.rsc.device.base import QLBaseDevice, intersection_positions
+from qlsdk.rsc.device.device_factory import DeviceFactory
+from qlsdk.rsc.interface import IDevice
+from qlsdk.rsc.device.base import QLBaseDevice
+
+class C21R(QLBaseDevice):
+    
+    device_type = 0x839  # C21R设备类型标识符 0x3908
+    
+    def __init__(self, socket):
+        super().__init__(socket)
+    
+        # 存储通道反向映射位置值
+        self._reverse_ch_pos  = None    
+        
+        # 存储通道反向映射位置值
+        self._impedance_ch_pos  = None    
+        self._impedance_channels_origin = None      
+        
+        self.channel_name_mapping = {
+            "FPz": 1, 
+            "FP1": 2, 
+            "FP2": 3, 
+            "Fz": 4, 
+            "F3": 5, 
+            "F7": 6, 
+            "F4": 7, 
+            "F8": 8,
+            "Cz": 9, 
+            "C3": 10, 
+            "T3": 11, 
+            "C4": 12, 
+            "T4": 13, 
+            "Pz": 14, 
+            "P3": 15, 
+            "T5": 16, 
+            "P4": 17, 
+            "T6": 18, 
+            "Qz": 19, 
+            "O1": 20, 
+            "O2": 21,
+            "M1": 22,
+            "M2": 23, 
+        }
+        
+        self.channel_mapping = {
+            "1": 48, 
+            "2": 59, 
+            "3": 60, 
+            "4": 16, 
+            "5": 11, 
+            "6": 55, 
+            "7": 57, 
+            "8": 15,
+            "9": 49, 
+            "10": 53, 
+            "11": 63, 
+            "12": 50, 
+            "13": 24, 
+            "14": 40, 
+            "15": 37, 
+            "16": 34, 
+            "17": 18, 
+            "18": 47, 
+            "19": 38, 
+            "20": 51, 
+            "21": 62,
+            "22": 14,
+            "23": 10
+        }
+        
+        self.channel_display_mapping = {
+            48: 1,  
+            59: 2,  
+            60: 3,  
+            16: 4,  
+            11: 5,  
+            55: 6,  
+            57: 7,  
+            15: 8, 
+            49: 9,  
+            53: 10, 
+            63: 11, 
+            50: 12, 
+            24: 13, 
+            40: 14, 
+            37: 15, 
+            34: 16, 
+            18: 17, 
+            47: 18, 
+            38: 19, 
+            51: 20, 
+            62: 21,
+            14: 22,
+            10: 23
+        }
+    
+    @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 'C21R')
+        logger.debug(f"EDF Handler initialized")
+        # 设置采集参数
+    def set_acq_param(self, channels:list, sample_rate: int = 500, sample_range:int = 188):
+        # 通道合法性校验
+        self._channel_validate(channels)
+        # 保存原始通道参数
+        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  
+    
+    @property
+    def acq_channels(self):
+        if self._acq_channels is None:
+            # 初始化通道参数为1-11
+            self.set_acq_param([i for i in range(1, 12)])
+        return self._acq_channels  
+    
+    def set_impedance_channels(self, channels:list):
+        # 通道合法性校验
+        self._channel_validate(channels)
+        # 保存原始通道参数
+        self._impedance_channels_origin = 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._impedance_channels = channels
+        
+        # 初始化位置映射
+        self._impedance_ch_pos  = None  
+        
+    def get_impedance_channels(self): 
+        if self._impedance_channels is None or len(self._impedance_channels) == 0:
+            self.set_impedance_channels([i for i in range(1, 12)])
+        return self._impedance_channels   
+    
+    def _channel_validate(self, channels: list):
+        # 名称转换为数字通道  
+        temp_channels = [self.channel_name_mapping.get(str(i).upper(), i) for i in channels]
+        
+        # 根据映射关系做通道转换-没有映射的默认到第一个通道
+        # 先设置不存在的通道为-1，再把-1替换为第一个通道，避免第一个通道也不合法的情况
+        temp_channels = [self.channel_mapping.get(str(i), -1) for i in temp_channels]
+        for i in range(len(temp_channels)):
+            if temp_channels[i] == -1:
+                raise ValueError(f"通道参数有误，通道应为1-23的数字或对应名称，如：1、2或FP1、FP2等")
+    
+    def _impedance_wrapper(self, body: bytes):        
+        packet = ImpedancePacket().transfer(body)   
+        impedance_channels = self.get_impedance_channels() 
+        if impedance_channels is not None and len(impedance_channels) > 0:
+            # 只保留设置的阻抗通道
+            channel_pos = intersection_positions(packet.channels, impedance_channels)
+            packet.impedance = [packet.impedance[i] for i in channel_pos]
+            packet.channels = [packet.channels[i] for i in channel_pos]
+            
+        # 升级为类变量，减少计算
+        if self._impedance_ch_pos is None:
+            self._impedance_ch_pos = map_indices(impedance_channels, packet.channels)
+            
+        packet.channels = self._impedance_channels_origin
+        packet.impedance = [packet.impedance[i] for i in self._impedance_ch_pos]
+            
+        return packet
+    
+    # 信号数据转换(默认不处理)
+    def _signal_wrapper(self, body: bytes):
+        if body is None:
+            return
+        data = RscPacket().transfer(body)
+        # 根据映射关系做通道转换-（注意数据和通道的一致性）
+        # 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]
+        
+        return data
+        
+    def start_stimulation(self):
+        raise NotImplementedError("Stimulation function is not supported")
+        
+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]
+
+DeviceFactory.register(C21R.device_type, C21R)