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

qlsdk/__init__.py

@@ -5,6 +5,7 @@ from .ar4m import AR4M
 from .ar4 import AR4
 from .x8 import X8
 from .x8m import X8M
+from .rsc import *
 
 __all__ = ['AR4M', 'AR4', 'AR4Packet', 'X8']
 

qlsdk/core/__init__.py

@@ -0,0 +1,5 @@
+from qlsdk.core.crc import *
+from qlsdk.core.message import *
+from qlsdk.core.local import *
+from qlsdk.core.utils import *
+from qlsdk.core.entity import *

qlsdk/core/crc/__init__.py

@@ -0,0 +1,5 @@
+from .crctools import crc16
+
+# packet crc validate
+def check_crc(data):
+    return int.from_bytes(data[-2:], 'little')  == crc16(data[:-2])

qlsdk/core/crc/crctools.py

@@ -0,0 +1,95 @@
+# len=256
+CRC_HI = [
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
+    0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
+    0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
+    0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
+    0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
+]
+
+# len=256
+CRC_LO = [
+    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
+    0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
+    0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
+    0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
+    0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
+    0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
+    0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
+    0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
+    0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
+    0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
+    0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
+    0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
+    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
+    0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
+    0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
+    0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
+    0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
+    0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
+    0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
+    0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
+    0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
+    0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
+    0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
+    0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
+    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
+    0x43, 0x83, 0x41, 0x81, 0x80, 0x40
+]
+
+def crc16(data):
+    crcHi = 0xFF
+    crcLo = 0xFF
+    for i in range(len(data)):
+        index = crcHi ^ data[i]
+        crcHi = crcLo ^ CRC_HI[index]
+        crcLo = CRC_LO[index]
+
+    return crcHi << 8 | crcLo
+
+class CRCEnum(object):
+    CRC8 = 8
+    CRC16 = 16
+    CRC32 = 32
+
+class CRC(object):
+    def __init__(self, width=CRCEnum.CRC16) :
+        self.width = width
+        self.crcHi = 0xFF
+        self.crcLo = 0xFF
+    
+    def _init(self):
+        if self.width == CRCEnum.CRC16:
+            self.crcHi = 0xFF
+            self.crcLo = 0xFF
+
+    def calc(self, data):
+        for i in range(len(data)):
+            index = self.crcHi ^ data[i]
+            self.crcHi = self.crcLo ^ CRC_HI[index]
+            self.crcLo = CRC_LO[index]
+
+    def checksum(self):
+        return self.crcHi << 8 | self.crcLo
+        

qlsdk/core/device.py

@@ -0,0 +1,25 @@
+# from abc import ABC, abstractmethod
+
+class BaseDevice(object):
+    def __init__(self, socket = None):
+        self.socket = socket
+        self.device_name = None
+        self.device_type = None
+        self.device_id = None
+        
+    @property
+    def acq_channels(self) :
+        return None
+    @property
+    def sample_range(self) -> int:
+        return None
+    @property
+    def sample_rate(self) -> int:
+        return None
+    @property
+    def sample_num(self) -> int:
+        return 10
+    @property
+    def resolution(self):
+        return 24
+    

qlsdk/core/entity/__init__.py

@@ -0,0 +1,92 @@
+from qlsdk.core.utils import to_channels
+from loguru import logger
+
+class DataPacket(object):
+    def __init__(self, device_type, device_id, channels, data):
+        self.data = data
+        self.channels = None
+        
+            
+class RscPacket(object):
+    def __init__(self):
+        self.time_stamp = None
+        self.pkg_id = None
+        self.result = None
+        self.channels = None
+        self.origin_sample_rate = None
+        self.sample_rate = None
+        self.sample_num = None
+        self.resolution = None
+        self.filter = None
+        self.data_len = None
+        self.trigger = None
+        self.eeg = None
+    
+    def transfer(self, body: bytes) -> 'RscPacket':
+        self.time_stamp = int.from_bytes(body[0:8], 'little')
+        self.result = body[8]
+        self.pkg_id = int.from_bytes(body[9: 13], 'little')
+        self.channels = to_channels(body[13: 45])
+        self.origin_sample_rate = int.from_bytes(body[45: 49], 'little')
+        self.sample_rate = int.from_bytes(body[49: 53], 'little')
+        self.sample_num = int.from_bytes(body[53: 57], 'little')
+        self.resolution = int(int(body[57]) / 8)
+        self.filter = body[58]
+        self.data_len = int.from_bytes(body[59: 63], 'little')
+        # 步径 相同通道的点间隔
+        step = int(len(self.channels) * self.resolution + 4)
+        self.trigger = [int.from_bytes(body[i:i+4], 'little') for i in range(63, len(body) - 3, step)]
+        b_eeg = body[63:]
+        ch_num = len(self.channels) 
+        self.eeg = [
+            [
+                int.from_bytes(b_eeg[i * self.resolution + 4 + j * step:i * self.resolution + 4 + j * step + 3], 'big', signed=True)
+                for j in range(self.sample_num)
+            ]
+            for i in range(ch_num)
+        ]
+                
+        # logger.trace(self)
+        return self
+        
+    def __str__(self):
+        return f"""
+            time_stamp: {self.time_stamp}
+            pkg_id: {self.pkg_id}
+            origin_sample_rate: {self.origin_sample_rate}
+            sample_rate: {self.sample_rate}
+            sample_num: {self.sample_num}
+            resolution: {self.resolution}
+            filter: {self.filter}
+            channels: {self.channels}
+            data len: {self.data_len}
+            trigger: {self.trigger}
+            eeg: {self.eeg}
+        """
+        
+class ImpedancePacket(object):
+    def __init__(self):
+        self.time_stamp = None
+        self.pkg_id = None
+        self.result = None
+        self.channels = None
+        self.data_len = None
+        self.impedance = None
+        
+    def transfer(self, body:bytes) -> 'ImpedancePacket':
+        self.time_stamp = int.from_bytes(body[0:8], 'little')
+        self.result = body[8]
+        self.pkg_id = int.from_bytes(body[9: 13], 'little')
+        self.channels = to_channels(body[13: 45])
+        
+        logger.debug(f"impedance: {self}")
+        
+    def __str__(self):
+        return f"""
+            time_stamp: {self.time_stamp}
+            pkg_id: {self.pkg_id}
+            result: {self.result}
+            channels: {self.channels}
+            data len: {self.data_len}
+            impedance: {self.impedance}
+        """

qlsdk/core/filter/__init__.py

@@ -0,0 +1 @@
+from .norch import notch_filter_50hz

qlsdk/core/filter/norch.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+def notch_filter_50hz(data: np.ndarray, 
+                     fs: float,
+                     notch_width: float = 2.0,
+                     max_harmonics: int = 5) -> np.ndarray:
+    """
+    多通道50Hz谐波陷波滤波器
+    
+    参数：
+    data : 输入信号，形状为 [通道数, 采样点数] 的二维数组
+    fs : 采样频率 (Hz)
+    notch_width : 陷波带宽 (Hz)，默认2Hz
+    max_harmonics : 最大谐波次数，默认处理前10次谐波
+    
+    返回：
+    滤波后的信号，形状与输入相同
+    """
+    # 输入校验
+    if data.ndim != 2:
+        raise ValueError("输入必须为二维数组 [channels, samples]")
+    if fs <= 0:
+        raise ValueError("采样频率必须为正数")
+
+    n_channels, n_samples = data.shape
+    nyquist = fs / 2
+    processed = np.empty_like(data)
+    
+    # 生成频率轴
+    freqs = np.fft.fftfreq(n_samples, 1/fs)
+    
+    for ch in range(n_channels):
+        # FFT变换
+        fft_data = np.fft.fft(data[ch])
+        
+        # 生成陷波掩模
+        mask = np.ones(n_samples, dtype=bool)
+        
+        # 计算需要消除的谐波
+        for k in range(1, max_harmonics+1):
+            target_freq = 50 * k
+            
+            # 超过奈奎斯特频率则停止
+            if target_freq > nyquist:
+                break
+                
+            # 生成陷波范围
+            notch_range = (np.abs(freqs - target_freq) <= notch_width/2) | \
+                          (np.abs(freqs + target_freq) <= notch_width/2)
+            
+            mask &= ~notch_range
+        
+        # 应用频域滤波
+        filtered_fft = fft_data * mask
+        
+        # 逆变换并取实数部分
+        processed[ch] = np.real(np.fft.ifft(filtered_fft))
+    
+    return processed

qlsdk/core/local.py

@@ -0,0 +1,34 @@
+import os
+import socket
+from time import time
+
+# 读取本机全部ip列表
+# return list
+def get_ips():
+    return socket.gethostbyname_ex(socket.gethostname())[-1]
+
+# 读取本机的ip地址
+# return str
+def get_ip():
+    # 优先读取活跃ip地址
+    routes = os.popen('route print').readlines()
+    for idx, item in enumerate(routes):
+        if ' 0.0.0.0 ' in item and len(item.split()) > 2:
+            return item.split()[-2]
+    
+    # 取第一个地址
+    ips = get_ips()
+    if len(ips) > 0 :
+        return ips[0]
+
+    raise ValueError("Ip address not exists.")
+
+def get_cache(fname=None):
+    if fname is None:
+        fname = int(time())
+    
+    cpath = os.path.abspath(os.path.abspath(__file__))
+    print(cpath)
+
+if __name__ == '__main__':
+    get_cache()

qlsdk/core/message/__init__.py

@@ -0,0 +1,2 @@
+from .command import *
+from .udp import UDPMessage

qlsdk/core/message/command.py

@@ -0,0 +1,324 @@
+import abc
+from time import time_ns
+from typing import Dict, Type
+from enum import Enum
+from loguru import logger
+from qlsdk.core.crc import crc16
+from qlsdk.core.device import BaseDevice
+from qlsdk.core.entity import RscPacket, ImpedancePacket
+from qlsdk.core.utils import to_channels, to_bytes
+
+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: BaseDevice):
+        self.device = device
+        
+    @classmethod
+    def build(cls, device) :
+        return cls(device)
+    
+    @property
+    @abc.abstractmethod
+    def cmd_code(self) -> int:
+        pass
+    @property
+    @abc.abstractmethod
+    def cmd_desc(self) -> str:
+        pass
+    
+    @staticmethod
+    def checksum(data: bytes) -> bytes:
+        return crc16(data).to_bytes(2, 'little')
+
+    def pack(self, body=b'') -> bytes:
+        # header+body+checksum
+        body = self.pack_body()
+        header = self.pack_header(len(body))
+        payload = header + body
+        return payload + DeviceCommand.checksum(payload)
+    def pack_body(self) -> bytes:
+        """构建消息体"""
+        return b''
+    def pack_header(self, body_len: int) -> bytes:
+        device_id = int(self.device.device_id) if self.device and self.device.device_id else 0
+        device_type = int(self.device.device_type) if self.device and self.device.device_type else 0
+        
+        """构建消息头"""
+        return (
+            DeviceCommand.HEADER_PREFIX
+            + int(2).to_bytes(1, 'little')     # pkgType  
+            + 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
+            + self.cmd_code.to_bytes(2, 'little')
+        )
+    
+    def unpack(self, payload: bytes) -> bytes:
+        """解析消息体"""
+        # 解析消息体
+        body = payload[self.HEADER_LEN:-2]   
+    
+    def parse_body(self, body: bytes):
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        logger.info(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
+        
+    
+
+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.trace(f"Creating command for code: {hex(code)}")
+        if code not in cls._commands:
+            logger.warning(f"不支持的设备指令: {hex(code)}")
+            return cls._commands[DefaultCommand.cmd_code]
+        return cls._commands[code]
+
+# =============================================================================
+class DefaultCommand(DeviceCommand):    
+    cmd_code = 0x00   
+    cmd_desc = "未定义"
+        
+    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
+    cmd_desc = "设备信息"
+    
+    def parse_body(self, body: bytes):
+        # 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 = int.from_bytes(body[9:13], 'big')
+        # deviceType - 4B
+        self.device.device_type = int.from_bytes(body[13:17], 'little')
+        # 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
+    cmd_desc = "握手"
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received handshake response: {body.hex()}")
+
+# 查询电量
+class QueryBatteryCommand(DeviceCommand):
+    cmd_code = 0x16
+    cmd_desc = "电量信息"
+    def parse_body(self, body: bytes):
+        # 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]
+            logger.debug(f"电量更新: {self.device}")
+        else:
+            logger.warning(f"QueryBatteryCommand message received but result is failed.")
+
+# 设置采集参数
+class SetAcquisitionParamCommand(DeviceCommand):
+    cmd_code = 0x451
+    cmd_desc = "设置信号采集参数"
+    
+    def pack_body(self):
+        body = to_bytes(self.device.acq_channels) 
+        body += self.device.sample_range.to_bytes(4, byteorder='little')
+        body += self.device.sample_rate.to_bytes(4, byteorder='little')
+        body += self.device.sample_num.to_bytes(4, byteorder='little')
+        body += self.device.resolution.to_bytes(1, byteorder='little')
+        body += bytes.fromhex('00')        
+
+        return body
+        
+# 启动采集
+class StartAcquisitionCommand(DeviceCommand):
+    cmd_code = 0x452
+    cmd_desc = "启动信号采集"
+    
+    def pack_body(self):
+        return bytes.fromhex('0000')
+
+# 停止采集
+class StopAcquisitionCommand(DeviceCommand):
+    cmd_code = 0x453
+    cmd_desc = "停止信号采集"
+    
+    def pack_body(self):
+        return b''
+
+        
+# 设置阻抗采集参数
+class SetImpedanceParamCommand(DeviceCommand):
+    cmd_code = 0x411
+    cmd_desc = "设置阻抗测量参数"
+        
+# 启动阻抗测量
+class StartImpedanceCommand(DeviceCommand):
+    cmd_code = 0x412
+    cmd_desc = "启动阻抗测量"
+    def pack_body(self):
+        body = bytes.fromhex('0000')
+        body += to_bytes(self.device.acq_channels)
+        body += bytes.fromhex('0000000000000000') # 8字节占位符
+        return body
+        
+
+# 停止阻抗测量
+class StopImpedanceCommand(DeviceCommand):
+    cmd_code = 0x413
+    cmd_desc = "停止阻抗测量"
+    
+    def pack_body(self):
+        return b''
+            
+# 启动刺激
+class StartStimulationCommand(DeviceCommand):
+    cmd_code = 0x48C
+    cmd_desc = "启动刺激"
+    def pack_body(self):
+        return self.device.stim_paradigm.to_bytes()
+        # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
+    def parse_body(self, body: bytes):
+        # time - 8B
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        # error_channel - 8B
+        # error_channel= int.from_bytes(body[9:17], 'big')
+        channels = to_channels(body[9:17])
+        logger.success(f"通道 {channels} 刺激开始")
+        self.device.trigger(f"通道 {channels} 刺激开始")
+        # error_type - 1B
+        error_type = body[17]
+
+# 停止刺激
+class StopStimulationCommand(DeviceCommand):
+    cmd_code = 0x488
+    cmd_desc = "停止刺激"
+     
+# 启动刺激
+class StopStimulationNotifyCommand(DeviceCommand):
+    cmd_code = 0x48D
+    cmd_desc = "停止刺激通知"
+    def pack_body(self):
+        return self.device.stim_paradigm.to_bytes()
+        # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
+    def parse_body(self, body: bytes):
+        # time - 8B
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        # error_channel - 8B
+        # error_channel= int.from_bytes(body[9:17], 'big')
+        channels = to_channels(body[9:17])
+        logger.success(f"通道 {channels} 刺激结束")
+        self.device.trigger(f"通道 {channels} 刺激结束", time)
+        # error_type - 1B
+        error_type = body[17]   
+# 刺激信息
+class StimulationInfoCommand(DeviceCommand):
+    cmd_code = 0x48e
+    cmd_desc = "刺激告警信息"
+    
+    def parse_body(self, body: bytes):
+        time = int.from_bytes(body[0:8], 'little')
+        # result - 1B
+        result = body[8]
+        # error_channel - 8B
+        channels = to_channels(body[9:17])
+        # 保留位-8B
+        # error_type - 1B
+        err_type = body[17]
+        # 特征位-4B
+        # errType  = int.from_bytes(body[25:29], 'little')
+        logger.warning(f"刺激告警信息[{err_type}]，通道 {channels} 刺激驱动不足")
+        
+
+# 阻抗数据
+class ImpedanceDataCommand(DeviceCommand):
+    cmd_code = 0x415
+    cmd_desc = "阻抗数据"
+    
+    def parse_body(self, body: bytes):
+        logger.info(f"Received impedance data: {body.hex()}")
+        packet = ImpedancePacket().transfer(body)
+
+# 信号数据
+class SignalDataCommand(DeviceCommand):
+    cmd_code = 0x455
+    cmd_desc = "信号数据"
+    
+    def unpack(self, payload):
+        return super().unpack(payload)
+    
+    def parse_body(self, body: bytes):                
+        if len(self.device.signal_consumers) > 0 or self.device.edf_handler:
+            # 解析数据包
+            packet = RscPacket()
+            packet.transfer(body)
+            
+            # 发送数据包到订阅者
+            for q in list(self.device.signal_consumers.values()):
+                q.put(packet)
+                
+            # 文件写入到edf
+            if self.device.edf_handler:
+                self.device.edf_handler.write(packet)
+
+# =============================================================================
+# 指令实现类注册到指令工厂
+# =============================================================================
+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(StimulationInfoCommand.cmd_code, StimulationInfoCommand)
+CommandFactory.register_command(ImpedanceDataCommand.cmd_code, ImpedanceDataCommand)
+CommandFactory.register_command(SignalDataCommand.cmd_code, SignalDataCommand)
+
+