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

qlsdk/rsc/command/message.py

@@ -1,8 +1,16 @@
 import abc
+import numpy as np
+from time import time_ns
 from typing import Dict, Type
-from enum import Enum
 from loguru import logger
-from rsc.core.crctools import crc16
+
+
+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
+from qlsdk.rsc.interface import IDevice, IParser
+from qlsdk.rsc.device import DeviceFactory
 
 class DeviceCommand(abc.ABC):
     # 消息头
@@ -12,7 +20,7 @@ class DeviceCommand(abc.ABC):
     # 消息指令码位置
     CMD_POS = 12
     
-    def __init__(self, device):
+    def __init__(self, device: BaseDevice):
         self.device = device
         
     @classmethod
@@ -23,6 +31,10 @@ class DeviceCommand(abc.ABC):
     @abc.abstractmethod
     def cmd_code(self) -> int:
         pass
+    @property
+    @abc.abstractmethod
+    def cmd_desc(self) -> str:
+        pass
     
     @staticmethod
     def checksum(data: bytes) -> bytes:
@@ -30,17 +42,23 @@ class DeviceCommand(abc.ABC):
 
     def pack(self, body=b'') -> bytes:
         # header+body+checksum
-        header = self.header_pack(len(body))
+        body = self.pack_body()
+        header = self.pack_header(len(body))
         payload = header + body
         return payload + DeviceCommand.checksum(payload)
-    
-    def header_pack(self, body_len: int) -> bytes:
+    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
-            + self.device.pkg_type.to_bytes(1, 'little')            
-            + self.device.device_type.to_bytes(1, 'little')
-            + self.device.device_id.to_bytes(4, 'little')
+            + 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')
         )
@@ -48,33 +66,14 @@ class DeviceCommand(abc.ABC):
     def unpack(self, payload: bytes) -> bytes:
         """解析消息体"""
         # 解析消息体
-        body = payload[self.HEADER_LEN:-2]
-    
-    
-class DeviceInfoCommand(DeviceCommand):
-    """设备信息指令"""
-    cmd_code = 0x01
-    
-    def parse_body(self, body: bytes):
-        # 解析设备信息
-        pass
-
-class SignalDataCommand(DeviceCommand):
-    """设备信息指令"""
-    cmd_code = 0x02
+        body = payload[self.HEADER_LEN:-2]   
     
     def parse_body(self, body: bytes):
-        # 解析设备信息
-        pass
-    
-if __name__ == "__main__":
-    # 测试代码
-    device = None  # 这里应该是设备实例
-    command1 = DeviceInfoCommand.build(device)
-    logger.debug(command1.cmd_code)
-    command2 = SignalDataCommand.build(device)
-    logger.debug(command2.cmd_code)
-    
+        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:
@@ -87,15 +86,16 @@ class CommandFactory:
     
     @classmethod
     def create_command(cls, code: int) -> Type[DeviceCommand]:
-        logger.debug(f"Creating command for code: {hex(code)}")
+        logger.trace(f"Creating command for code: {hex(code)}")
         if code not in cls._commands:
-            logger.warning(f"Unsupported command code: {hex(code)}")
+            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
@@ -103,32 +103,36 @@ class DefaultCommand(DeviceCommand):
     
 class GetDeviceInfoCommand(DeviceCommand):
     cmd_code = 0x17
+    cmd_desc = "设备信息"
     
     def parse_body(self, body: bytes):
-        logger.info(f"Received GetDeviceInfoCommand body len: {len(body)}")
-        # time - 8b
+        # time - 8B
         self.device.connect_time = int.from_bytes(body[0:8], 'little')
         self.device.current_time = self.device.connect_time
-        # result - 1b
+        # 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
+        # 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
+        # hardVersion - 4B
         self.device.hardware_version = body[21:25].hex()
-        # deviceName - 16b
+        # deviceName - 16B
         self.device.device_name = body[25:41].decode('utf-8').rstrip('\x00')
-        # flag - 4b
+        # flag - 4B
         flag = int.from_bytes(body[41:45], 'little')
         logger.debug(f"Received device info: {result}, {flag}, {self.device}")
         
+        # 创建设备对象
+        device = Dev
+        
 
 # 握手
 class HandshakeCommand(DeviceCommand):
     cmd_code = 0x01
+    cmd_desc = "握手"
     
     def parse_body(self, body: bytes):
         logger.info(f"Received handshake response: {body.hex()}")
@@ -136,8 +140,8 @@ class HandshakeCommand(DeviceCommand):
 # 查询电量
 class QueryBatteryCommand(DeviceCommand):
     cmd_code = 0x16
+    cmd_desc = "电量信息"
     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
@@ -152,78 +156,168 @@ class QueryBatteryCommand(DeviceCommand):
             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
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetAcquisitionParam response: {body.hex()}")
+    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
-    def parse_body(self, body: bytes):
-        logger.info(f"Received acquisition start response: {body.hex()}")
+    cmd_desc = "启动信号采集"
+    
+    def pack_body(self):
+        return bytes.fromhex('0000')
 
 # 停止采集
 class StopAcquisitionCommand(DeviceCommand):
     cmd_code = 0x453
+    cmd_desc = "停止信号采集"
     
-    def parse_body(self, body: bytes):
-        logger.info(f"Received acquisition stop response: {body.hex()}")
+    def pack_body(self):
+        return b''
+
+        
 # 设置阻抗采集参数
 class SetImpedanceParamCommand(DeviceCommand):
     cmd_code = 0x411
-    def parse_body(self, body: bytes):
-        logger.info(f"Received SetImpedanceParamCommand response: {body.hex()}")
-# 启动采集
+    cmd_desc = "设置阻抗测量参数"
+        
+# 启动阻抗测量
 class StartImpedanceCommand(DeviceCommand):
     cmd_code = 0x412
-    def parse_body(self, body: bytes):
-        logger.info(f"Received StartImpedanceCommand response: {body.hex()}")
+    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 parse_body(self, body: bytes):
-        logger.info(f"Received StopImpedanceCommand response: {body.hex()}")
-        
-# 启动采集
+    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):
-        logger.info(f"Received acquisition start response: {body.hex()}")
+        # 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):
-        logger.info(f"Received acquisition stop response: {body.hex()}")
+        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):        
-        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)
+    def parse_body(self, body: bytes):     
+        # 解析数据包
+        packet = RscPacket()
+        packet.transfer(body)  
+        
+        # 文件写入到edf
+        if self.device.edf_handler:
+            self.device.edf_handler.write(packet)
+                        
+        if len(self.device.signal_consumers) > 0 :
+            # 信号数字值转物理值
+            packet.eeg = self.device.eeg2phy(np.array(packet.eeg))
+            
+            # 发送数据包到订阅者
+            for q in list(self.device.signal_consumers.values()):
+                q.put(packet)
+                
+            
 
 # =============================================================================
-# Command Registration
+# 指令实现类注册到指令工厂
 # =============================================================================
-
 CommandFactory.register_command(DefaultCommand.cmd_code, DefaultCommand)
 CommandFactory.register_command(GetDeviceInfoCommand.cmd_code, GetDeviceInfoCommand)
 CommandFactory.register_command(HandshakeCommand.cmd_code, HandshakeCommand)
@@ -235,5 +329,8 @@ CommandFactory.register_command(SetImpedanceParamCommand.cmd_code, SetImpedanceP
 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)
+CommandFactory.register_command(SignalDataCommand.cmd_code, SignalDataCommand)
+
+

qlsdk/rsc/device/__init__.py

@@ -0,0 +1,2 @@
+from .base import QLBaseDevice
+from .device_factory import DeviceFactory