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

qlsdk/rsc/command/message.py

@@ -0,0 +1,239 @@
+import abc
+from typing import Dict, Type
+from enum import Enum
+from loguru import logger
+from rsc.core.crctools import crc16
+
+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
+        
+    @classmethod
+    def build(cls, device) :
+        return cls(device)
+    
+    @property
+    @abc.abstractmethod
+    def cmd_code(self) -> int:
+        pass
+    
+    @staticmethod
+    def checksum(data: bytes) -> bytes:
+        return crc16(data).to_bytes(2, 'little')
+
+    def pack(self, body=b'') -> bytes:
+        # header+body+checksum
+        header = self.header_pack(len(body))
+        payload = header + body
+        return payload + DeviceCommand.checksum(payload)
+    
+    def header_pack(self, body_len: int) -> bytes:
+        """构建消息头"""
+        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')
+            + (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]
+    
+    
+class DeviceInfoCommand(DeviceCommand):
+    """设备信息指令"""
+    cmd_code = 0x01
+    
+    def parse_body(self, body: bytes):
+        # 解析设备信息
+        pass
+
+class SignalDataCommand(DeviceCommand):
+    """设备信息指令"""
+    cmd_code = 0x02
+    
+    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)
+    
+    
+
+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)

qlsdk/rsc/device_manager.py

@@ -0,0 +1,117 @@
+import socket
+from typing import Optional
+from loguru import logger   
+from qlsdk.rsc.discover import UdpBroadcaster
+from threading import Thread
+from qlsdk.core import *
+from qlsdk.rsc.entity import QLDevice
+from qlsdk.rsc.proxy import DeviceProxy
+import time
+        
+        
+class DeviceContainer(object):
+    def __init__(self, proxy_enabled=False, tcp_port = 19216):
+        self._devices = {}
+        self._tcp_port = tcp_port
+        self._proxy_enabled = proxy_enabled
+        
+        # 设备搜索广播器
+        self._broadcaster = UdpBroadcaster()
+        self._broadcaster.start()
+        
+        # 监听设备连接
+        self._listening_thread = Thread(target=self._listening)
+        self._listening_thread.daemon = True
+        self._listening_thread.start()
+        
+    @property
+    def devices(self)-> QLDevice:
+        return self._devices
+    
+    '''
+        等待设备连接
+    '''
+    def connect(self, device_id: str, timeout:int=30) -> Optional[QLDevice]:        
+        logger.info(f"Searching for device: {device_id}")
+        self.add_search(device_id)
+        for _ in range(timeout):
+            device = self.get_device(device_id)
+            if device:
+                logger.success(f"Device {device_id} connected")
+                return device
+            time.sleep(1)
+        logger.error(f"Device {device_id} not found")
+        return None
+            
+    def _listening(self):
+        tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            # 绑定到所有接口的19216端口
+            tcp_socket.bind(('0.0.0.0', self._tcp_port))
+            tcp_socket.listen(5)
+            logger.info(f"端口[{self._tcp_port}]监听服务已启动")
+
+            while True:
+                client_socket, addr = tcp_socket.accept()
+                logger.info(f"接收到来自 {addr[0]}:{addr[1]} 的连接")
+                
+                
+                # 为每个新连接创建线程处理
+                client_handler = Thread(
+                    target=self.client_handler,
+                    args=(client_socket,)
+                )
+                client_handler.daemon = True
+                client_handler.start()
+                
+        except KeyboardInterrupt:
+            logger.error(f"端口[{self._tcp_port}]监听服务异常关闭")
+        finally:
+            logger.error(f"端口[{self._tcp_port}]监听服务关闭")
+            tcp_socket.close()
+            
+    def client_handler(self, client_socket):
+                
+        if self._proxy_enabled:
+            proxy = DeviceProxy(client_socket)
+            proxy.start()
+        else:            
+            # 数据监听
+            device = QLDevice(client_socket)
+            # GET_DEVICE_INFO
+            msg = GetDeviceInfoCommand.build(device).pack()
+            logger.info(f"发送获取设备信息命令: {msg.hex()}")
+            device.send(msg)
+            # 添加设备
+            while True:
+                if device.device_name:
+                    self.add_device(device)
+                    break
+            
+        
+    # 搜寻设备
+    def add_search(self, device_id):
+        self._broadcaster.add_device(device_id)
+        
+    def add_device(self, device: QLDevice):
+        if device is None or device.device_name is None:
+            logger.warning("无效的设备")
+            
+        self._devices.update({device.device_name: device})
+        logger.debug(f"add_device {device.device_name} then has devices {self._devices}")
+        
+        self._broadcaster.remove_device(device.device_name)
+        logger.debug(f"add_device {device.device_name} then has broadcaster {self._broadcaster}")
+        
+    def get_device(self, device_id=None)->QLDevice:
+        logger.trace(f"已连接设备数量:{len(self._devices)}")
+        if len(self._devices) == 0:
+            return None
+        
+        # 未指定device_id，返回第一个设备
+        if device_id is None:
+            return list(self._devices.values())[0]
+        
+        return self._devices.get(device_id)
+            

qlsdk/rsc/discover.py

@@ -0,0 +1,87 @@
+import socket
+import time
+from threading import Thread, Lock
+from loguru import logger
+
+from qlsdk.core.message import UDPMessage
+
+class UdpBroadcaster:
+    # 广播端口需要和ar4sdk做区分， 使用54366时不能和x8同时使用
+    def __init__(self, port=54366):
+        self.broadcast_port = port
+        self.devices_to_broadcast = []  # 待广播的设备序列号列表
+        self.connected_devices = set()  # 已连接的设备序列号集合
+        self.lock = Lock()  # 用于线程安全的锁
+        self.running = True
+
+        # 创建UDP socket
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+    def add_device(self, device_id):
+        """添加设备序列号到待广播列表"""
+        with self.lock:
+            if device_id not in self.devices_to_broadcast:
+                self.devices_to_broadcast.append(device_id)
+                logger.info(f"Added device {device_id} to broadcast list.")
+
+    def remove_device(self, device_id):
+        """从待广播列表中移除设备序列号"""
+        with self.lock:
+            if device_id in self.devices_to_broadcast:
+                self.devices_to_broadcast.remove(device_id)
+                logger.info(f"Removed device {device_id} from broadcast list.")
+
+    def mark_device_as_connected(self, device_id):
+        """将设备标记为已连接，并从未广播列表中移除"""
+        with self.lock:
+            if device_id in self.devices_to_broadcast:
+                self.devices_to_broadcast.remove(device_id)
+            self.connected_devices.add(device_id)
+            logger.info(f"Device {device_id} is now connected.")
+
+    def broadcast_devices(self):
+        """轮询发送广播"""
+        while self.running:
+            with self.lock:
+                for device_id in self.devices_to_broadcast:
+                    message = UDPMessage.search(device_id)
+                    self.sock.sendto(message, ('<broadcast>', self.broadcast_port))
+                    logger.info(f"Broadcasting device ID: {device_id}")
+            time.sleep(1)  # 每隔1秒发送一次广播
+
+    def start(self):
+        """启动广播线程"""
+        self.broadcast_thread = Thread(target=self.broadcast_devices)
+        self.broadcast_thread.setDaemon(True)
+        self.broadcast_thread.start()
+
+    def stop(self):
+        """停止广播"""
+        self.running = False
+        self.broadcast_thread.join()
+        self.sock.close()
+
+# 示例使用
+if __name__ == "__main__":
+    broadcaster = UdpBroadcaster()
+
+    # 添加设备序列号到待广播列表
+    broadcaster.add_device_to_broadcast("390024130032")
+
+    # 启动广播
+    broadcaster.start()
+
+    try:
+        # 模拟运行一段时间
+        time.sleep(10)
+
+        # 标记设备为已连接
+        broadcaster.mark_device_as_connected("390024130032")
+
+        # 继续运行一段时间
+        time.sleep(10)
+
+    finally:
+        # 停止广播
+        broadcaster.stop()