qlsdk2 0.3.0a2__py3-none-any.whl → 0.4.0a1__py3-none-any.whl

qlsdk/core/message/udp.py

@@ -0,0 +1,96 @@
+
+from enum import Enum
+from time import timezone
+from qlsdk.core.crc import check_crc, crc16
+from qlsdk.core.local import get_ip
+
+from loguru import logger
+
+
+class UDPCommand(Enum):
+    CONNECT = 0x10
+    NOTIFY = 0x09
+
+
+class UDPMessage(object):
+    START = "SHQuanLan"
+    MAC = 'mac'
+    DEV_TYPE = "dev_type"
+    VERSION_CODE = "version_code"
+    VERSION_NAME = "version_name"
+
+    def __init__(self) -> None:
+        self._base = None
+        self._message = None
+
+    @staticmethod
+    def parse(packet, address = None):
+        plen = len(packet)
+        if plen < 10:
+            logger.trace("message length too short.")
+            return
+
+        start = packet[:9].decode("utf-8")
+        # quanlan udp message
+        if start != UDPMessage.START:
+            return
+
+        if not check_crc(packet):
+            logger.warn(f"数据CRC校验失败，丢弃！")
+            return
+        
+        # message command
+        cmd = int.from_bytes(packet[10:12], 'little')
+
+        return UDPMessage._parse(cmd, packet[12:])
+
+    @staticmethod
+    def _parse(cmd, data):
+        # 只解析0x09
+        if cmd == UDPCommand.NOTIFY.value:
+            return UDPMessage.parseDeviceInfo(data)
+        else:
+            logger.trace(f'不支持的消息. cmd: {hex(cmd)} dlen: {len(data)} data: {data}')
+            return None
+        
+    @staticmethod
+    def parseDeviceInfo(data):
+        device_info = {}
+        try:
+            device_info[UDPMessage.DEV_TYPE] = hex(int.from_bytes(data[:2], 'little'))
+            device_info[UDPMessage.MAC] = hex(int.from_bytes(data[2:10], 'little'))
+            device_info[UDPMessage.VERSION_CODE] = int.from_bytes(data[42:46], 'little')
+            device_info[UDPMessage.VERSION_NAME] = str(data[10:42],'utf-8').split('\x00')[0]
+        except Exception as e:
+            logger.error(f"parseDeviceInfo异常：{e}")
+
+        return device_info
+
+    @staticmethod
+    def search(device_id : str, server_ip : str=None, server_port : int=19216):
+        # 服务端Ip
+        if server_ip is None:
+            server_ip = get_ip()
+            
+        logger.debug(f"search device {device_id} on {server_ip}:{server_port}")
+            
+        message = bytearray(28)
+        # 消息头
+        message[:10] = UDPMessage.START.encode('utf-8')
+        # 消息类型
+        message[10:12] = UDPCommand.CONNECT.value.to_bytes(2, 'little')
+        # 设备序列号格式沿用现有协议
+        serial_no = f'F0{device_id[:2]}FFFFFFFF{device_id[4:]}' 
+        message[12:22] = bytes.fromhex(serial_no)
+        # 本机ip
+        ip = server_ip.split(".")    
+        message[22] = (int)(ip[0])
+        message[23] = (int)(ip[1])
+        message[24] = (int)(ip[2])
+        message[25] = (int)(ip[3])
+        # 服务端端口（按大端输出）
+        message[26:28] = server_port.to_bytes(2, 'big')
+        # 校验和（按小端输出）
+        checksum = crc16(message).to_bytes(2, 'little')
+
+        return message + checksum

qlsdk/core/utils.py

@@ -0,0 +1,68 @@
+from bitarray import bitarray
+from loguru import logger
+# 通道数组[1,2,3,...]转换为bytes
+def to_bytes(channels: list[int], upper=256) -> bytes:
+    byte_len = int(upper / 8)
+    channel = [0] * byte_len
+    result = bitarray(upper)
+    result.setall(0)
+    for i in range(len(channels)):
+        if channels[i] > 0 and channels[i] <= upper: 
+            # 每个字节从低位开始计数
+            m = (channels[i] - 1) % 8
+            result[channels[i] + 6 - 2 * m] = 1
+    return result.tobytes()
+
+# 通道bytes转换为数组[1,2,3,...]
+def to_channels(data: bytes) -> list[int]:
+    ba = bitarray()
+    ba.frombytes(data)
+    channels = []
+    for i in range(len(ba)):
+        if ba[i] == 1:
+            m = i % 8
+            channels.append(i + 8 - 2 * m)
+    return channels
+
+def bytes_to_ints(b):
+    """将小端字节序的3字节bytes数组转换为int数组"""
+    if len(b) % 3 != 0:
+        raise ValueError("输入的bytes长度必须是3的倍数")
+    return [
+        b[i] | (b[i + 1] << 8) | (b[i + 2] << 16)
+        for i in range(0, len(b), 3)
+    ]
+    
+def bytes_to_int(b: bytes) -> int:
+    """将小端字节序的3字节bytes数组转换为int数组"""
+    if len(b)  != 3:
+        raise ValueError("输入的bytes长度必须是3的倍数")
+    return b[0] | (b[1] << 8) | (b[2] << 16)
+def bytes_to_ints2(b):
+    """将小端字节序的3字节bytes数组转换为int数组"""
+    if len(b) % 3 != 0:
+        raise ValueError("输入的bytes长度必须是3的倍数")
+    return [
+        b[i] | (b[i + 1] << 8) | (b[i + 2] << 16)
+        for i in range(0, len(b), 3)
+    ]
+   
+import numpy as np 
+if __name__ == "__main__":
+    
+    channels = [1]
+    channels1 = [1, 2, 3, 4]
+    channels2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]
+    channels3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256]
+    channels4 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]
+    logger.info(to_bytes(channels).hex())
+    logger.info(to_bytes(channels1).hex())
+    logger.info(to_bytes(channels2).hex())
+    logger.info(to_bytes(channels3).hex())
+    logger.info(to_bytes(channels4).hex())
+    
+    bs = 'ffffffffffffff7f000000000000000000000000000000000000000000000000'
+    bs1 = '8000000000000000000000000000000000000000000000000000000000000000'
+    bs2 = '0100000000000000000000000000000000000000000000000000000000000000'
+    logger.info(to_channels(bytes.fromhex(bs1)))
+    logger.info(to_channels(bytes.fromhex(bs2)))

qlsdk/persist/__init__.py

@@ -1 +1,2 @@
-from .edf import EdfHandler
+from .edf import EdfHandler
+from .rsc_edf import RscEDFHandler

qlsdk/{ar4m/persist.py → persist/rsc_edf.py}

@@ -6,15 +6,118 @@ from loguru import logger
 import numpy as np
 import os
 
-class EdfHandler(object):
-    def __init__(self, sample_frequency, physical_max, physical_min, digital_max, digital_min, resolution=16, storage_path = None):
+class EDFWriterThread(Thread):
+    def __init__(self, edf_writer : EdfWriter):
+        super().__init__(self)
+        self._edf_writer : EdfWriter = edf_writer
+        self.data_queue : Queue = Queue()
+        self._stop_event : bool = False
+        self._recording = False
+        self._chunk = np.array([])
+        self._points = 0
+        self._duration = 0
+        self._sample_frequency = 0
+        self._total_packets = 0
+        self._channels = []
+        self._sample_rate = 0
+        
+    def start(self):
+        self._stop_event = False
+        super().start()
+        
+    def stop(self):
+        self._stop_event = True
+        
+    def append(self, data):
+        # 数据
+        self.data_queue.put(data)
+        
+    def _consumer(self):
+        logger.debug(f"开始消费数据 _consumer: {self.data_queue.qsize()}")
+        while True:
+            if self._recording or (not self.data_queue.empty()):
+                try:
+                    data = self.data_queue.get(timeout=10)
+                    if data is None:
+                        break
+                    # 处理数据
+                    self._points += len(data)
+                    self._write_file(data)
+                except Exception as e:
+                    logger.error("数据队列为空，超时(10s)结束")
+                    break
+            else:
+                break
+            
+        self.close()
+        
+    def _write_file(self, eeg_data):
+        try:            
+            if (self._chunk.size == 0):
+                self._chunk = np.asarray(eeg_data)
+            else:                
+                self._chunk = np.hstack((self._chunk, eeg_data))
+                
+            if self._chunk.size >= self._sample_rate * self._channels:                
+                self._write_chunk(self._chunk[:self._sample_rate])
+                self._chunk = self._chunk[self._sample_rate:]            
+            
+        except Exception as e:
+            logger.error(f"写入数据异常: {str(e)}")
+        
+    def close(self):
+        self._recording = False
+        if self._edf_writer:            
+            self._end_time = datetime.now().timestamp()
+            self._edf_writer.writeAnnotation(0, 1, "start recording ")
+            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}")
+        
+    
+        
+    def _write_chunk(self, chunk):
+        logger.debug(f"写入数据: {chunk}")
+        # 转换数据类型为float64（pyedflib要求）
+        data_float64 = chunk.astype(np.float64)
+        # 写入时转置为(样本数, 通道数)格式
+        self._edf_writer.writeSamples(data_float64)
+        self._duration += 1
+
+class RscEDFHandler(object):
+    '''
+        Rsc EDF Handler
+        处理EDF文件的读写
+        RSC设备通道数根据选择变化，不同通道采样频率相同
+        sample_frequency: 采样频率
+        physical_max: 物理最大值    
+        physical_min: 物理最小值
+        digital_max: 数字最大值
+        digital_min: 数字最小值
+        resolution: 分辨率
+        storage_path: 存储路径        
+        
+        @author: qlsdk
+        @since: 0.4.0
+    '''
+    def __init__(self, sample_frequency, physical_max, physical_min, digital_max, digital_min, resolution=32, storage_path = None):
+        # edf文件参数
         self.physical_max = physical_max
         self.physical_min = physical_min
         self.digital_max = digital_max
         self.digital_min = digital_min
-        self.channels = None
-        self._cache = Queue()
+        # 点分辨率
         self.resolution = resolution
+        # eeg通道数
+        self.eeg_channels = None
+        # eeg采样率
+        self.eeg_sample_rate = 500
+        self.acc_channels = None
+        self.acc_sample_rate = 50
+        # 缓存
+        self._cache = Queue()
+        # 采样频率
         self.sample_frequency = sample_frequency
         # bytes per second
         self.bytes_per_second = 0
@@ -38,6 +141,7 @@ class EdfHandler(object):
         self._total_packets = 0
         self._lost_packets = 0
         self._storage_path = storage_path
+        self._edf_writer_thread = None
         
     @property
     def file_name(self): 
@@ -66,95 +170,55 @@ class EdfHandler(object):
     def set_patient_name(self, patient_name):
         self._patient_name = patient_name
     
-    def append(self, data):
+    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}")
+            
         if data:
-            # 通道数
-            if self._first_pkg_id is None:
-                self.channels = data.eeg_ch_count
-                self._first_pkg_id = data.pkg_id
-                self._first_timestamp = data.time_stamp
+            # # 通道数
+            # 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._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)
-        if not self._recording:
-            self.start()
+        self._edf_writer_thread.append(data)
+        # if not self._recording:
+        #     self.start()
     
     def trigger(self, data):
         pass        
-    
-    def start(self):
-        self._recording = True
-        record_thread = Thread(target=self._consumer)
-        record_thread.start()
         
-    def _consumer(self):
-        logger.debug(f"开始消费数据 _consumer: {self._cache.qsize()}")
-        while True:
-            if self._recording or (not self._cache.empty()):
-                data = self._cache.get()
-                if data is None:
-                    break
-                # 处理数据
-                self._points += len(data.eeg[0])
-                self._write_file(data.eeg)
-            else:
-                break
-            
-        self.close()
-        
-    def _write_file(self, data):
-        try:
-            if self._edf_writer is None:
-                self.initialize_edf()
-            
-            if (self._chunk.size == 0):
-                self._chunk = np.asarray(data)
-            else:                
-                self._chunk = np.hstack((self._chunk, data))
-                
-            if self._chunk.size >= self.sample_frequency * self.channels:                
-                self._write_chunk(self._chunk[:self.sample_frequency])
-                self._chunk = self._chunk[self.sample_frequency:]            
-            
-        except Exception as e:
-            logger.error(f"写入数据异常: {str(e)}")
-        
-    def close(self):
-        self._recording = False
-        if self._edf_writer:            
-            self._end_time = datetime.now().timestamp()
-            self._edf_writer.writeAnnotation(0, 1, "start recording ")
-            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}")
-        
-    
-        
-    def initialize_edf(self):
+    def init_edf_writer(self):
         # 创建EDF+写入器
-        self._edf_writer = EdfWriter(
+        edf_writer = EdfWriter(
             self.file_name,
-            self.channels,
+            self.eeg_channels,
             file_type=self.file_type
         )
         
         # 设置头信息
-        self._edf_writer.setPatientCode(self._patient_code)
-        self._edf_writer.setPatientName(self._patient_name)
-        self._edf_writer.setEquipment(self._device_type)
-        self._edf_writer.setStartdatetime(datetime.now())
+        edf_writer.setPatientCode(self._patient_code)
+        edf_writer.setPatientName(self._patient_name)
+        edf_writer.setEquipment(self._device_type)
+        edf_writer.setStartdatetime(datetime.now())
         
         # 配置通道参数
         signal_headers = []
-        for ch in range(self.channels):
+        for ch in range(self.eeg_channels):
             signal_headers.append({
                 "label": f'channels {ch + 1}',
                 "dimension": 'uV',
@@ -165,14 +229,8 @@ class EdfHandler(object):
                 "digital_max": self.digital_max
             })
         
-        self._edf_writer.setSignalHeaders(signal_headers)
-    
-    def _write_chunk(self, chunk):
-        logger.debug(f"写入数据: {chunk}")
-        # 转换数据类型为float64（pyedflib要求）
-        data_float64 = chunk.astype(np.float64)
-        # 写入时转置为(样本数, 通道数)格式
-        self._edf_writer.writeSamples(data_float64)
-        self._duration += 1
+        edf_writer.setSignalHeaders(signal_headers)
+        
+        return edf_writer
 
     

qlsdk/rsc/__init__.py

@@ -0,0 +1,7 @@
+from .discover import *
+
+from .entity import DeviceParser, QLDevice
+from .command import *
+from .device_manager import DeviceContainer
+from .proxy import DeviceProxy
+from .paradigm import *

qlsdk/rsc/command/__init__.py

@@ -0,0 +1,214 @@
+import abc
+from typing import Dict, Type
+from enum import Enum
+from loguru import logger
+from qlsdk.core import crc16
+
+class UDPCommand(Enum):
+    CONNECT = 0x10
+    NOTIFY = 0x09
+    
+
+class DeviceCommand(abc.ABC):
+    # 消息头
+    HEADER_PREFIX = b'\x5A\xA5'
+    # 消息头总长度 2(prefix) +1(pkgType) +1(deviceType) +4(deviceId) +4(len) +2(cmd)
+    HEADER_LEN = 14  
+    # 消息指令码位置
+    CMD_POS = 12
+    
+    def __init__(self, device):
+        self.device = device
+    @property
+    @abc.abstractmethod
+    def cmd_code(self) -> int:
+        pass
+
+    @classmethod
+    def pack(cls, body=b'') -> bytes:
+        # header+body+checksum
+        header = DeviceCommand.build_header(cls.cmd_code, len(body))
+        payload = header + body
+        return payload + DeviceCommand.calculate_checksum(payload)
+
+    @staticmethod
+    def build_header(cmd_code, body_len: int = 0, pkg_type=2, device_type=0, device_id=0) -> bytes:
+        """Construct protocol header"""
+        return (
+            DeviceCommand.HEADER_PREFIX
+            + pkg_type.to_bytes(1, 'little')            
+            + device_type.to_bytes(1, 'little')
+            + device_id.to_bytes(4, 'little')
+            + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
+            + cmd_code.to_bytes(2, 'little')
+        )
+
+    @staticmethod
+    def calculate_checksum(data: bytes) -> bytes:
+        return crc16(data).to_bytes(2, 'little')
+
+    @abc.abstractmethod
+    def parse_body(self, body: bytes):
+        """Implement in subclasses for command-specific parsing"""
+        pass
+
+class CommandFactory:
+    """Registry for command implementations"""
+    _commands: Dict[int, Type[DeviceCommand]] = {}
+    
+    @classmethod
+    def register_command(cls, code: int, command: Type[DeviceCommand]):
+        cls._commands[code] = command
+    
+    @classmethod
+    def create_command(cls, code: int) -> Type[DeviceCommand]:
+        logger.debug(f"Creating command for code: {hex(code)}")
+        if code not in cls._commands:
+            logger.warning(f"Unsupported command code: {hex(code)}")
+            return cls._commands[DefaultCommand.cmd_code]
+        return cls._commands[code]
+
+# =============================================================================
+class DefaultCommand(DeviceCommand):    
+    cmd_code = 0x00   
+        
+    def parse_body(self, body: bytes):
+        # Response parsing example: 2 bytes version + 4 bytes serial
+        logger.info(f"Received body len: {len(body)}")
+    
+class GetDeviceInfoCommand(DeviceCommand):
+    cmd_code = 0x17
+    
+    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
+        # result - 1b
+        result = body[8]
+        # deviceId - 4b
+        self.device.device_id = body[9:13].hex()
+        # deviceType - 4b
+        self.device.device_type = body[13:17].hex()
+        # softVersion - 4b
+        self.device.software_version = body[17:21].hex()
+        # hardVersion - 4b
+        self.device.hardware_version = body[21:25].hex()
+        # deviceName - 16b
+        self.device.device_name = body[25:41].decode('utf-8').rstrip('\x00')
+        # flag - 4b
+        flag = int.from_bytes(body[41:45], 'little')
+        logger.debug(f"Received device info: {result}, {flag}, {self.device}")
+        
+
+# 握手
+class HandshakeCommand(DeviceCommand):
+    cmd_code = 0x01
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received handshake response: {body.hex()}")
+
+# 查询电量
+class QueryBatteryCommand(DeviceCommand):
+    cmd_code = 0x16
+    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
+        result = body[8]
+        # 更新设备信息
+        if result == 0:
+            # voltage - 2b mV
+            self.device.voltage = int.from_bytes(body[9:11], 'little')
+            # soc - 1b
+            self.device.battery_remain = body[11]
+            # soh - 1b
+            self.device.battery_total = body[12]
+            # state - 1b
+            # state = body[13]
+        else:
+            logger.warning(f"QueryBatteryCommand message received but result is failed.")
+
+# 设置采集参数
+class SetAcquisitionParamCommand(DeviceCommand):
+    cmd_code = 0x451
+    def parse_body(self, body: bytes):
+        logger.info(f"Received SetAcquisitionParam response: {body.hex()}")
+        
+# 启动采集
+class StartAcquisitionCommand(DeviceCommand):
+    cmd_code = 0x452
+    def parse_body(self, body: bytes):
+        logger.info(f"Received acquisition start response: {body.hex()}")
+
+# 停止采集
+class StopAcquisitionCommand(DeviceCommand):
+    cmd_code = 0x453
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received acquisition stop response: {body.hex()}")
+# 设置阻抗采集参数
+class SetImpedanceParamCommand(DeviceCommand):
+    cmd_code = 0x411
+    def parse_body(self, body: bytes):
+        logger.info(f"Received SetImpedanceParamCommand response: {body.hex()}")
+# 启动采集
+class StartImpedanceCommand(DeviceCommand):
+    cmd_code = 0x412
+    def parse_body(self, body: bytes):
+        logger.info(f"Received StartImpedanceCommand response: {body.hex()}")
+
+# 停止采集
+class StopImpedanceCommand(DeviceCommand):
+    cmd_code = 0x413
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received StopImpedanceCommand response: {body.hex()}")
+        
+# 启动刺激
+class StartStimulationCommand(DeviceCommand):
+    cmd_code = 0x48C
+    def parse_body(self, body: bytes):
+        logger.info(f"Received acquisition start response: {body.hex()}")
+
+# 停止刺激
+class StopStimulationCommand(DeviceCommand):
+    cmd_code = 0x488
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received acquisition stop response: {body.hex()}")
+
+# 阻抗数据
+class ImpedanceDataCommand(DeviceCommand):
+    cmd_code = 0x415
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received impedance data: {body.hex()}")
+
+# 信号数据
+class SignalDataCommand(DeviceCommand):
+    cmd_code = 0x455
+    
+    def parse_body(self, body: bytes):        
+        logger.info(f"Received signal data: {len(body)}字节, the subscribe is {self.device.signal_consumers}")
+        for q in list(self.device.signal_consumers.values()):
+            q.put(body)
+
+# =============================================================================
+# Command Registration
+# =============================================================================
+
+CommandFactory.register_command(DefaultCommand.cmd_code, DefaultCommand)
+CommandFactory.register_command(GetDeviceInfoCommand.cmd_code, GetDeviceInfoCommand)
+CommandFactory.register_command(HandshakeCommand.cmd_code, HandshakeCommand)
+CommandFactory.register_command(QueryBatteryCommand.cmd_code, QueryBatteryCommand)
+CommandFactory.register_command(SetAcquisitionParamCommand.cmd_code, SetAcquisitionParamCommand)
+CommandFactory.register_command(StartAcquisitionCommand.cmd_code, StartAcquisitionCommand)
+CommandFactory.register_command(StopAcquisitionCommand.cmd_code, StopAcquisitionCommand)
+CommandFactory.register_command(SetImpedanceParamCommand.cmd_code, SetImpedanceParamCommand)
+CommandFactory.register_command(StartImpedanceCommand.cmd_code, StartImpedanceCommand)
+CommandFactory.register_command(StopImpedanceCommand.cmd_code, StopImpedanceCommand)
+CommandFactory.register_command(StartStimulationCommand.cmd_code, StartStimulationCommand)
+CommandFactory.register_command(ImpedanceDataCommand.cmd_code, ImpedanceDataCommand)
+CommandFactory.register_command(SignalDataCommand.cmd_code, SignalDataCommand)