I. Analysis of Core Information in the R60ABD1 Datasheet

II. Hardware Connection and Construction of Debugging Environment (Necessary Preparatory Step)

2.1 Summary of Actual Measurement of R60ABD1 Instructions

2.1.1 Query and Setting of Basic Instruction Information

2.1.2 Query and Setting of Human Body Presence Instruction Information

2.1.3 Query and Setting of Heart Rate Monitoring Instruction Information

2.1.4 Query and Setting of Respiratory Monitoring Instruction Information

2.1.5 Query and Setting of Sleep Monitoring Instruction Information

2.2 Summary of Issues Related to R60ABD1

2.2.1 After disabling the four active reporting functions and restarting the device, no data response is generated when any single function is enabled separately

The following is the testing procedure conducted on the new firmware (G60SM1SYv010309):

 

The following are the same tests conducted on the old firmware version (G60SM1SYv010107):

This behavior does not conform to the typical "command-response" mode; when the unattended timing function is enabled, the firmware automatically triggers a query operation for the unattended timing duration internally.

2.2.3 Setting the Sleep Cut-off Duration the response does not match the description in the manual

After the sleep deadline query, the device additionally returned a response frame of "struggle state judgment", while the host did not send this query command.

III. Overall Architecture Design of MicroPython Driver

3.1 Overall Architecture Design

3.2 Design and Performance Verification of the DataFlowProcessor Class

3.2.1 Determination of Timer Call Cycle: Matching the Data Output Frequency of the Device

3.2.2 DataFlowProcessor Class: The Core Component for Decoupling Data Pipelines from Business Logic

3.2.2.1 Core Attributes: Data and State Carrying

class DataFlowProcessor:
    def __init__(self, uart):
        self.uart = uart  # 串口通信实例，负责底层收发
        self.buffer = bytearray()  # 数据缓冲区，处理粘包/半包
        self.stats = {  # 统计信息，用于调试与异常分析
            'total_bytes_received': 0,
            'total_frames_parsed': 0,
            'crc_errors': 0,
            'frame_errors': 0,
            'invalid_frames': 0
        }
        self.max_buffer_size = 128  # 缓冲区容量限制，防止内存溢出
        
        # 帧结构常量（与协议强绑定）
        self.HEADER = bytes([0x53, 0x59])
        self.TRAILER = bytes([0x54, 0x43])
        # 各字段长度定义（帧头、控制字、命令字等）
        self.HEADER_LEN = 2
        self.CONTROL_LEN = 1
        self.COMMAND_LEN = 1
        self.LENGTH_LEN = 2
        self.CRC_LEN = 1
        self.TRAILER_LEN = 2
        self.MIN_FRAME_LEN = self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN + self.LENGTH_LEN + self.CRC_LEN + self.TRAILER_LEN

3.2.2.2 Core Method: The Complete Pipeline from "Data Reading" to "Frame Parsing"

3.2.2.2.1 read_and_parse Entry for Data Reading and Frame Parsing

def read_and_parse(self):
    data = self.uart.read(32)  # 单次读取32字节，平衡效率与阻塞风险
    if not data:
        return []
    self.stats['total_bytes_received'] += len(data)
    self.buffer.extend(data)  # 数据存入缓冲区
    
    frames = []
    processed_bytes = 0
    while len(self.buffer) - processed_bytes >= self.MIN_FRAME_LEN:
        # 查找帧头（_find_header）
        header_pos = self._find_header(processed_bytes)
        if header_pos == -1:
            break
        
        # 解析数据长度（_parse_data_length）
        length_pos = header_pos + self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN
        data_len = self._parse_data_length(length_pos)
        total_frame_len = self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN + self.LENGTH_LEN + data_len + self.CRC_LEN + self.TRAILER_LEN
        
        # 提取并验证完整帧（帧尾_validate_trailer、CRC_validate_crc）
        frame_data = self.buffer[header_pos:header_pos+total_frame_len]
        if not self._validate_trailer(frame_data):
            self.stats['frame_errors'] += 1
            processed_bytes = header_pos + 1
            continue
        if not self._validate_crc(frame_data):
            self.stats['crc_errors'] += 1
            processed_bytes = header_pos + total_frame_len
            continue
        
        # 解析单帧（_parse_single_frame）
        parsed_frame = self._parse_single_frame(frame_data)
        if parsed_frame:
            frames.append(parsed_frame)
            self.stats['total_frames_parsed'] += 1
        else:
            self.stats['invalid_frames'] += 1
        processed_bytes = header_pos + total_frame_len
    
    # 清理已处理数据
    if processed_bytes > 0:
        self.buffer = self.buffer[processed_bytes:]
    return frames

3.2.2.2.3 Instruction Sending and Tool Methods

3.2.2.2.4 Complete Code

# Python env   : MicroPython v1.23.0
# -*- coding: utf-8 -*-        
# @Time    : 2025/11/4 下午6:38   
# @Author  : 李清水            
# @File    : data_flow_processor.py
# @Description : 用于处理R60ABD1雷达设备串口通信协议的数据流处理器类相关代码
# @License : CC BY-NC 4.0

# ======================================== 导入相关模块 =========================================

# ======================================== 全局变量 ============================================

# ======================================== 功能函数 ============================================

# ======================================== 自定义类 ============================================

class DataFlowProcessor:
    """
    R60ABD1 雷达设备串口通信协议的数据流处理器类。
    负责处理雷达设备的串口数据通信，包括数据帧的接收、解析、校验和发送。

    Attributes:
        uart (UART): 串口通信实例，用于数据收发。
        buffer (bytearray): 数据缓冲区，用于存储接收到的原始字节数据。
        stats (dict): 数据流转与解析统计信息字典，包含：
            total_bytes_received (int): 总接收字节数
            total_frames_parsed (int): 总解析帧数
            crc_errors (int): CRC校验错误次数
            frame_errors (int): 帧结构错误次数
            invalid_frames (int): 无效帧次数
        max_buffer_size (int): 缓冲区最大容量限制。

    Methods:
        __init__(uart): 初始化数据流处理器。
        read_and_parse(): 读取串口数据并解析完整帧。
        _find_header(start_pos=0): 在缓冲区中查找帧头位置。
        _parse_data_length(length_pos): 解析数据长度（大端格式）。
        _validate_trailer(frame_data): 验证帧尾。
        _validate_crc(frame_data): 验证CRC校验码。
        _parse_single_frame(frame_data): 解析单个数据帧。
        get_stats(): 获取数据流转与解析统计信息。
        clear_buffer(): 清空缓冲区。
        build_and_send_frame(control_byte, command_byte, data=b''): 构建并发送数据帧。
        _calculate_crc(data_bytes): 计算CRC校验码。

    ==========================================
    Data flow processor class for R60ABD1 radar device UART communication protocol.
    Handles UART data communication for radar devices, including data frame reception,
    parsing, validation, and transmission.

    Attributes:
        uart (UART): UART communication instance for data transmission and reception.
        buffer (bytearray): Data buffer for storing received raw byte data.
        stats (dict): Data flow and parsing statistics dictionary containing:
            total_bytes_received (int): Total bytes received
            total_frames_parsed (int): Total frames parsed
            crc_errors (int): CRC validation error count
            frame_errors (int): Frame structure error count
            invalid_frames (int): Invalid frame count
        max_buffer_size (int): Maximum buffer capacity limit.

    Methods:
        __init__(uart): Initialize data flow processor.
        read_and_parse(): Read UART data and parse complete frames.
        _find_header(start_pos=0): Find frame header position in buffer.
        _parse_data_length(length_pos): Parse data length (big-endian format).
        _validate_trailer(frame_data): Validate frame trailer.
        _validate_crc(frame_data): Validate CRC checksum.
        _parse_single_frame(frame_data): Parse single data frame.
        get_stats(): Get data flow and parsing statistics.
        clear_buffer(): Clear buffer.
        build_and_send_frame(control_byte, command_byte, data=b''): Build and send data frame.
        _calculate_crc(data_bytes): Calculate CRC checksum.
    """
    def __init__(self, uart):
        """
        初始化数据流处理器。

        Args:
            uart (UART): 已初始化的串口实例，用于数据收发。

        Returns:
            None

        Note:
            - 初始化时创建空缓冲区和统计信息字典。
            - 定义帧结构相关常量，包括帧头、帧尾、各字段长度等。
            - 设置缓冲区最大容量为128字节，防止内存溢出。

        ==========================================

        Initialize data flow processor.

        Args:
            uart (UART): Initialized UART instance for data transmission and reception.

        Returns:
            None

        Note:
            - Creates empty buffer and statistics dictionary during initialization.
            - Defines frame structure constants including header, trailer, field lengths, etc.
            - Sets maximum buffer capacity to 128 bytes to prevent memory overflow.
        """
        self.uart = uart
        self.buffer = bytearray()
        self.stats = {
            'total_bytes_received': 0,
            'total_frames_parsed': 0,
            'crc_errors': 0,
            'frame_errors': 0,
            'invalid_frames': 0
        }

        self.max_buffer_size = 128

        # 帧结构常量定义
        self.HEADER = bytes([0x53, 0x59])
        self.TRAILER = bytes([0x54, 0x43])
        self.HEADER_LEN = 2
        self.CONTROL_LEN = 1
        self.COMMAND_LEN = 1
        self.LENGTH_LEN = 2
        self.CRC_LEN = 1
        self.TRAILER_LEN = 2
        self.MIN_FRAME_LEN = self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN + self.LENGTH_LEN + self.CRC_LEN + self.TRAILER_LEN

    def read_and_parse(self):
        """
        读取串口数据并解析完整帧。

        Args:
            无

        Returns:
            list: 解析成功的数据帧列表，每个元素为解析后的帧字典。
            []: 无完整帧或解析失败时返回空列表。

        Raises:
            Exception: 底层串口操作可能抛出的异常会向上传播。

        Note:
            - 每次读取最多32字节数据，避免阻塞时间过长。
            - 采用滑动窗口方式处理缓冲区，逐步解析完整帧。
            - 自动处理CRC校验和帧结构验证，统计各类错误信息。
            - 方法执行期间会更新统计信息，调用get_stats()可获取最新状态。

        ==========================================

        Read UART data and parse complete frames.

        Args:
            None

        Returns:
            list: List of successfully parsed data frames, each element is a parsed frame dictionary.
            []: Returns empty list when no complete frames or parsing fails.

        Raises:
            Exception: Underlying UART operations may raise exceptions that propagate upward.

        Note:
            - Reads up to 32 bytes per call to avoid long blocking times.
            - Uses sliding window approach to process buffer and gradually parse complete frames.
            - Automatically handles CRC validation and frame structure verification, statistics various error types.
            - Updates statistics during execution, call get_stats() to get latest status.
        """
        # 读取串口数据
        data = self.uart.read(32)
        if not data:
            return []

        # 更新统计信息
        self.stats['total_bytes_received'] += len(data)

        # 检查缓冲区大小
        if len(self.buffer) > self.max_buffer_size:
            self.clear_buffer()

        # 将数据添加到缓冲区
        self.buffer.extend(data)

        frames = []
        processed_bytes = 0

        while len(self.buffer) - processed_bytes >= self.MIN_FRAME_LEN:
            # 查找帧头
            header_pos = self._find_header(processed_bytes)
            if header_pos == -1:
                # 没有找到更多帧头，跳出循环
                break

            # 从找到的帧头位置开始
            current_pos = header_pos

            # 检查是否有足够数据解析长度字段
            if current_pos + self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN + self.LENGTH_LEN > len(self.buffer):
                break

            # 解析数据长度（大端格式）
            length_pos = current_pos + self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN
            data_len = self._parse_data_length(length_pos)

            # 计算完整帧长度
            total_frame_len = self.HEADER_LEN + self.CONTROL_LEN + self.COMMAND_LEN + self.LENGTH_LEN + data_len + self.CRC_LEN + self.TRAILER_LEN

            # 检查是否有完整的帧
            if current_pos + total_frame_len > len(self.buffer):
                break

            # 提取完整帧数据
            frame_end = current_pos + total_frame_len
            frame_data = self.buffer[current_pos:frame_end]

            # 验证帧尾
            if not self._validate_trailer(frame_data):
                self.stats['frame_errors'] += 1
                # 帧尾错误，跳过这个帧头，继续查找下一个
                processed_bytes = current_pos + 1
                continue

            # 验证CRC
            if not self._validate_crc(frame_data):
                self.stats['crc_errors'] += 1
                # CRC错误，跳过这个帧，继续查找下一个
                processed_bytes = current_pos + total_frame_len
                continue

            # 解析单帧
            parsed_frame = self._parse_single_frame(frame_data)
            if parsed_frame:
                frames.append(parsed_frame)
                self.stats['total_frames_parsed'] += 1
            else:
                self.stats['invalid_frames'] += 1

            # 移动到下一帧
            processed_bytes = current_pos + total_frame_len

        # 清理已处理的数据
        if processed_bytes > 0:
            self.buffer = self.buffer[processed_bytes:]

        return frames

    def _find_header(self, start_pos=0):
        """
        在缓冲区中查找帧头位置。

        Args:
            start_pos (int): 起始搜索位置，默认为0。

        Returns:
            int: 找到的帧头位置索引，未找到返回-1。

        Note:
            - 帧头为固定字节序列 [0x53, 0x59]。
            - 搜索范围从start_pos到缓冲区末尾-1（需要连续两个字节）。
            - 采用线性搜索算法，时间复杂度O(n)。

        ==========================================

        Find frame header position in buffer.

        Args:
            start_pos (int): Starting search position, defaults to 0.

        Returns:
            int: Found header position index, returns -1 if not found.

        Note:
            - Frame header is fixed byte sequence [0x53, 0x59].
            - Search range from start_pos to buffer end-1 (requires two consecutive bytes).
            - Uses linear search algorithm with O(n) time complexity.
        """
        for i in range(start_pos, len(self.buffer) - 1):
            if self.buffer[i] == self.HEADER[0] and self.buffer[i + 1] == self.HEADER[1]:
                return i
        return -1

    def _parse_data_length(self, length_pos):
        """
        解析数据长度（大端格式）。

        Args:
            length_pos (int): 长度字段在缓冲区中的起始位置。

        Returns:
            int: 解析出的数据长度值，解析失败返回0。

        Note:
            - 长度字段采用大端格式存储：高字节在前，低字节在后。
            - 需要确保length_pos+1不超出缓冲区范围。
            - 返回值为数据部分的实际字节长度。

        ==========================================

        Parse data length (big-endian format).

        Args:
            length_pos (int): Starting position of length field in buffer.

        Returns:
            int: Parsed data length value, returns 0 if parsing fails.

        Note:
            - Length field uses big-endian format: high byte first, low byte last.
            - Ensures length_pos+1 does not exceed buffer bounds.
            - Return value is the actual byte length of data portion.
        """
        if length_pos + 1 >= len(self.buffer):
            return 0
        # 大端格式：高字节在前，低字节在后
        return (self.buffer[length_pos] << 8) | self.buffer[length_pos + 1]

    def _validate_trailer(self, frame_data):
        """
        验证帧尾。

        Args:
            frame_data (bytes|bytearray): 完整帧数据。

        Returns:
            bool: 帧尾验证通过返回True，否则返回False。

        Note:
            - 帧尾为固定字节序列 [0x54, 0x43]。
            - 检查帧数据最后两个字节是否匹配帧尾。
            - 帧尾验证失败表明帧结构不完整或数据损坏。

        ==========================================

        Validate frame trailer.

        Args:
            frame_data (bytes|bytearray): Complete frame data.

        Returns:
            bool: Returns True if trailer validation passes, False otherwise.

        Note:
            - Frame trailer is fixed byte sequence [0x54, 0x43].
            - Checks if last two bytes of frame data match trailer.
            - Trailer validation failure indicates incomplete frame structure or data corruption.
        """
        if len(frame_data) < 2:
            return False
        return (frame_data[-2] == self.TRAILER[0] and
                frame_data[-1] == self.TRAILER[1])

    def _validate_crc(self, frame_data):
        """
        验证CRC校验码。

        Args:
            frame_data (bytes|bytearray): 完整帧数据。

        Returns:
            bool: CRC验证通过返回True，否则返回False。

        Note:
            - CRC校验范围：帧头到数据部分（不包括CRC字节和帧尾）。
            - 计算方式：对校验数据求和后取低8位。
            - CRC位于帧数据倒数第3个字节位置。

        ==========================================

        Validate CRC checksum.

        Args:
            frame_data (bytes|bytearray): Complete frame data.

        Returns:
            bool: Returns True if CRC validation passes, False otherwise.

        Note:
            - CRC check range: from header to data portion (excluding CRC byte and trailer).
            - Calculation method: sum check data and take lower 8 bits.
            - CRC is located at the third last byte of frame data.
        """
        if len(frame_data) < 3:
            return False

        # 计算校验和（不包括CRC字节和帧尾）
        data_to_check = frame_data[:-3]
        calculated_crc = sum(data_to_check) & 0xFF
        received_crc = frame_data[-3]

        return calculated_crc == received_crc

    def _parse_single_frame(self, frame_data):
        """
        解析单个数据帧。

        Args:
            frame_data (bytes|bytearray): 完整帧数据。

        Returns:
            dict|None: 解析成功返回帧信息字典，解析失败返回None。

        Raises:
            Exception: 解析过程中发生异常时记录错误信息。

        Note:
            - 按协议格式依次解析：帧头→控制字→命令字→长度字段→数据→CRC→帧尾。
            - 返回字典包含所有解析出的字段和原始数据。
            - 解析失败会记录到invalid_frames统计中。

        ==========================================

        Parse single data frame.

        Args:
            frame_data (bytes|bytearray): Complete frame data.

        Returns:
            dict|None: Returns frame information dictionary on success, None on failure.

        Raises:
            Exception: Records error information when exceptions occur during parsing.

        Note:
            - Parses sequentially according to protocol format: header→control→command→length→data→CRC→trailer.
            - Return dictionary contains all parsed fields and raw data.
            - Parsing failures are recorded in invalid_frames statistics.
        """
        try:
            pos = 0

            # 解析帧头 (2字节)
            header = bytes(frame_data[pos:pos + 2])
            pos += 2

            # 控制字 (1字节)
            control_byte = frame_data[pos]
            pos += 1

            # 命令字 (1字节)
            command_byte = frame_data[pos]
            pos += 1

            # 长度标识 (2字节)
            data_length = (frame_data[pos] << 8) | frame_data[pos + 1]
            pos += 2

            # 数据 (n字节)
            data_end = pos + data_length
            if data_end > len(frame_data) - 3:  # -3 为CRC(1)+帧尾(2)
                return None
            data = bytes(frame_data[pos:data_end])
            pos = data_end

            # CRC (1字节)
            crc = frame_data[pos]
            pos += 1

            # 帧尾 (2字节)
            trailer = bytes(frame_data[pos:pos + 2])

            # 构建解析结果
            parsed_frame = {
                'header': header,
                'control_byte': control_byte,
                'command_byte': command_byte,
                'data_length': data_length,
                'data': data,
                'crc': crc,
                'trailer': trailer,
                'raw_data': bytes(frame_data)
            }

            return parsed_frame

        except Exception as e:
            print(f"Frame parsing error: {e}")
            return None

    def get_stats(self):
        """
        获取数据流转与解析统计信息。

        Args:
            无

        Returns:
            dict: 包含所有统计信息的字典副本。

        Note:
            - 返回统计信息的深拷贝，防止外部修改影响内部数据。
            - 统计信息包括：接收字节数、解析帧数、各类错误计数等。

        ==========================================

        Get data flow and parsing statistics.

        Args:
            None

        Returns:
            dict: Dictionary containing all statistics information (copy).

        Note:
            - Returns deep copy of statistics to prevent external modifications affecting internal data.
            - Statistics include: received bytes, parsed frames, various error counts, etc.
        """
        return self.stats.copy()

    def clear_buffer(self):
        """
        清空缓冲区。

        Args:
            无

        Returns:
            None

        Note:
            - 将缓冲区重置为空bytearray。
            - 通常在缓冲区过大或需要重新开始解析时调用。

        ==========================================

        Clear buffer.

        Args:
            None

        Returns:
            None

        Note:
            - Resets buffer to empty bytearray.
            - Typically called when buffer is too large or need to restart parsing.
        """
        self.buffer = bytearray()

    def build_and_send_frame(self, control_byte, command_byte, data=b''):
        """
        构建并发送数据帧。

        Args:
            control_byte (int): 控制字，1字节无符号整数。
            command_byte (int): 命令字，1字节无符号整数。
            data (bytes): 数据部分，默认为空字节。

        Returns:
            bytes|None: 构建好的完整帧数据（用于调试），发送失败返回None。

        Raises:
            Exception: 帧构建或发送过程中发生异常时记录错误信息。

        Note:
            - 按照协议格式构建完整帧：帧头→控制字→命令字→长度→数据→CRC→帧尾。
            - 自动计算数据长度和CRC校验码。
            - 通过串口发送构建好的帧数据。

        ==========================================

        Build and send data frame.

        Args:
            control_byte (int): Control byte, 1-byte unsigned integer.
            command_byte (int): Command byte, 1-byte unsigned integer.
            data (bytes): Data portion, defaults to empty bytes.

        Returns:
            bytes|None: Built complete frame data (for debugging), returns None on send failure.

        Raises:
            Exception: Records error information when exceptions occur during frame building or sending.

        Note:
            - Builds complete frame according to protocol format: header→control→command→length→data→CRC→trailer.
            - Automatically calculates data length and CRC checksum.
            - Sends built frame data via UART.
        """
        try:
            # 帧头
            header = self.HEADER

            # 控制字和命令字
            control = bytes([control_byte])
            command = bytes([command_byte])

            # 数据长度（大端格式）
            data_length = len(data)
            length_bytes = bytes([(data_length >> 8) & 0xFF, data_length & 0xFF])

            # 组装除CRC和帧尾的部分
            frame_without_crc = header + control + command + length_bytes + data

            # 计算CRC
            crc = self._calculate_crc(frame_without_crc)

            # 帧尾A
            trailer = self.TRAILER

            # 完整帧
            complete_frame = frame_without_crc + bytes([crc]) + trailer

            # 发送帧
            self.uart.write(complete_frame)

            return complete_frame

        except Exception as e:
            print(f"Frame building and sending error: {e}")
            return None

    def _calculate_crc(self, data_bytes):
        """
        计算CRC校验码。

        Args:
            data_bytes (bytes): 需要计算CRC的数据字节序列。

        Returns:
            int: 计算出的CRC校验码（1字节）。

        Note:
            - 校验码计算：对输入数据所有字节求和后，取低8位。
            - 此CRC算法为简单求和校验，适用于基本错误检测。
            - CRC校验范围通常为帧头到数据部分。

        ==========================================

        Calculate CRC checksum.

        Args:
            data_bytes (bytes): Data byte sequence for CRC calculation.

        Returns:
            int: Calculated CRC checksum (1 byte).

        Note:
            - Checksum calculation: sum all input data bytes and take lower 8 bits.
            - This CRC algorithm uses simple sum check, suitable for basic error detection.
            - CRC check range typically from header to data portion.
        """
        return sum(data_bytes) & 0xFF

# ======================================== 初始化配置 ==========================================

# ========================================  主程序  ===========================================

3.2.3 Performance Verification

# Python env   :
# -*- coding: utf-8 -*-
# @Time    : 2025/11/4 下午5:33
# @Author  : 李清水
# @File    : main.py
# @Description :

from machine import UART, Pin, Timer
import time
from data_flow_processor import DataFlowProcessor

frame_count = 0

# 存储解析到的数据帧
parsed_frames_buffer = []

# 初始化UART0：TX=16, RX=17，波特率115200
uart = UART(0, baudrate=115200, tx=Pin(16), rx=Pin(17), timeout=0)

# 创建DataFlowProcessor实例
processor = DataFlowProcessor(uart)

# ======================================== 功能函数 ============================================

# 计时装饰器，用于计算函数运行时间
def timed_function(f: callable, *args: tuple, **kwargs: dict) -> callable:
    """
    计时装饰器，用于计算并打印函数/方法运行时间。

    Args:
        f (callable): 需要传入的函数/方法
        args (tuple): 函数/方法 f 传入的任意数量的位置参数
        kwargs (dict): 函数/方法 f 传入的任意数量的关键字参数

    Returns:
        callable: 返回计时后的函数
    """
    myname = str(f).split(' ')[1]

    def new_func(*args: tuple, **kwargs: dict) -> any:
        t: int = time.ticks_us()
        result = f(*args, **kwargs)
        delta: int = time.ticks_diff(time.ticks_us(), t)
        print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000))
        return result

    return new_func

def format_time():
    """格式化当前时间为 [YYYY-MM-DD HH:MM:SS.sss] 格式"""
    t = time.localtime()
    ms = time.ticks_ms() % 1000
    return f"[{t[0]}-{t[1]:02d}-{t[2]:02d} {t[3]:02d}:{t[4]:02d}:{t[5]:02d}.{ms:03d}]"

@timed_function
def timer_callback(timer):
    """定时器回调函数，每50ms触发一次，直接解析数据帧"""
    global frame_count, parsed_frames_buffer

    # 直接调用解析方法
    frames = processor.read_and_parse()

    # 将解析到的帧添加到缓冲区
    for frame in frames:
        frame_count += 1
        parsed_frames_buffer.append({
            'frame_number': frame_count,
            'control': frame['control_byte'],
            'command': frame['command_byte'],
            'data_length': frame['data_length'],
            'data_hex': frame['data'].hex() if frame['data'] else "",
            'raw_hex': frame['raw_data'].hex(),
            'timestamp': format_time()
        })

# 初始化50ms定时器
timer = Timer(-1)
timer.init(period=50, mode=Timer.PERIODIC, callback=timer_callback)

try:
    while True:
        # 检查是否需要打印缓冲区中的帧（每10个打印一次）
        if len(parsed_frames_buffer) >= 10:
            print("=====================================================")

            for frame_data in parsed_frames_buffer:
                print("[%s] Frame#%d: Control=0x%02X, Command=0x%02X, Length=%d, Data=%s" % (frame_data['timestamp'], frame_data['frame_number'], frame_data['control'], frame_data['command'], frame_data['data_length'], frame_data['data_hex']))
                print("[%s] Raw frame: %s" % (frame_data['timestamp'], frame_data['raw_hex']))
                print("-" * 60)

            print("=====================================================")

            # 清空缓冲区
            parsed_frames_buffer = []

        # 小延迟，避免占用太多CPU
        time.sleep(0.01)

except KeyboardInterrupt:
    # 停止定时器
    timer.deinit()

    # 打印剩余未输出的帧
    if parsed_frames_buffer:
        print("=====================================================")
        print("[%s] Final output %d parsed frames:" % (format_time(), len(parsed_frames_buffer)))
        for frame_data in parsed_frames_buffer:
            print("[%s] Frame#%d: Control=0x%02X, Command=0x%02X, Length=%d, Data=%s" % (frame_data['timestamp'], frame_data['frame_number'], frame_data['control'], frame_data['command'], frame_data['data_length'], frame_data['data_hex']))
            print("[%s] Raw frame: %s" % (frame_data['timestamp'], frame_data['raw_hex']))
            print("-" * 60)

    # 输出最终统计信息
    stats = processor.get_stats()
    print("[%s] Final statistics:" % format_time())
    print("  Total bytes received: %d" % stats['total_bytes_received'])
    print("  Total frames parsed: %d" % stats['total_frames_parsed'])
    print("  CRC errors: %d" % stats['crc_errors'])
    print("  Frame errors: %d" % stats['frame_errors'])
    print("  Invalid frames: %d" % stats['invalid_frames'])

3.3 R60ABD1 Class Design: Modularization Encapsulation of the Business Logic Layer

3.3.1 Instance Attribute Design: Layered Isolation by Functional Module

3.3.1.1 System Control and Status Attributes

self.parse_interval = parse_interval  # 数据解析周期，适配设备数据输出频率
self.max_retries = max_retries        # 指令重试次数，保障通信可靠性
self.retry_delay = retry_delay        # 重试间隔，避免频繁重试导致设备负载过高
self.init_timeout = init_timeout      # 初始化超时时间，防止设备未响应时无限等待

# 运行状态标志
self._is_running = False              # 设备是否处于运行状态
self._initialization_complete = False # 初始化是否完成
self._configuration_errors = []       # 配置错误记录，用于异常排查

3.3.1.2 System-level Monitoring Attributes

# 心跳包监控
self.heartbeat_last_received = 0      # 最后接收心跳包的时间戳（ms）
self.heartbeat_timeout_count = 0      # 心跳超时累计次数
self.heartbeat_interval = 0           # 实际心跳间隔统计（ms）

# 系统状态
self.system_initialized = False       # 初始化完成状态
self.system_initialized_timestamp = 0 # 初始化完成时间戳（ms）
self.module_reset_flag = False        # 模组复位状态标记
self.module_reset_timestamp = 0       # 模组复位时间戳（ms）

# 产品信息
self.product_model = ""               # 产品型号（如“R60ABD1”）
self.product_id = ""                  # 产品ID（唯一标识）
self.hardware_model = ""              # 硬件型号
self.firmware_version = ""            # 固件版本（如“G60SM1SYv010309”）

3.3.1.3 Radar Detection and Human Presence Attributes

# 位置状态
self.radar_in_range = False           # 是否在雷达探测范围内

# 人体存在基本状态
self.presence_enabled = presence_enabled # 人体存在功能开关
self.presence_status = 0              # 存在状态（0=无人，1=有人）
self.motion_status = 0                # 运动状态（0=无，1=静止，2=活跃）

# 量化数据
self.movement_parameter = 0           # 体动参数（0-100）
self.human_distance = 0               # 人体距离（0-65535 cm）
self.human_position_x = 0             # 人体X坐标（有符号）
self.human_position_y = 0             # 人体Y坐标（有符号）
self.human_position_z = 0             # 人体Z坐标（有符号）

3.3.1.4 Respiratory Monitoring Attributes

# 功能配置
self.breath_monitoring_enabled = breath_monitoring_enabled # 呼吸监测开关
self.breath_waveform_enabled = False                        # 呼吸波形上报开关
self.low_breath_threshold = 10                              # 低缓呼吸阈值（10-20次/min）

# 监测数据
self.breath_status = 0                # 呼吸状态（1=正常，2=过高，3=过低，4=无）
self.breath_value = 0                 # 呼吸数值（0-35次/分）
self.breath_waveform = [0, 0, 0, 0, 0] # 5字节呼吸波形数据

3.3.1.5 Heart Rate Monitoring Attributes

# 功能配置
self.heart_rate_enabled = heart_rate_enabled # 心率监测开关
self.heart_rate_waveform_enabled = False     # 心率波形上报开关

# 监测数据
self.heart_rate_value = 0              # 心率数值（60-120次/分）
self.heart_rate_waveform = [0, 0, 0, 0, 0] # 5字节心率波形数据

3.3.1.6 Sleep Monitoring Attributes

# 基础状态
self.sleep_monitoring_enabled = sleep_monitoring_enabled # 睡眠监测开关

# 入床/离床与睡眠状态
self.bed_status = 0                   # 床状态（0=离床，1=入床，2=无）
self.sleep_status = 0                 # 睡眠状态（0=深睡，1=浅睡，2=清醒，3=无）

# 时长统计
self.awake_duration = 0               # 清醒时长（分钟）
self.light_sleep_duration = 0         # 浅睡时长（分钟）
self.deep_sleep_duration = 0          # 深睡时长（分钟）

# 睡眠质量与异常
self.sleep_quality_score = 0          # 睡眠质量评分（0-100）
self.sleep_quality_rating = 0         # 睡眠质量评级
self.sleep_comprehensive_status = {}  # 睡眠综合状态（8字段字典）
self.sleep_anomaly = 0                # 睡眠异常状态
self.abnormal_struggle_status = 0     # 异常挣扎状态
self.no_person_timing_status = 0      # 无人计时状态

# 配置参数
self.abnormal_struggle_enabled = abnormal_struggle_enabled # 异常挣扎开关
self.no_person_timing_enabled = no_person_timing_enabled   # 无人计时开关
self.no_person_timing_duration = no_person_timing_duration # 无人计时时长
self.sleep_cutoff_duration = sleep_cutoff_duration         # 睡眠截止时长
self.struggle_sensitivity = struggle_sensitivity           # 挣扎灵敏度

3.3.1.7 Query and Timer Management Attributes

# 查询状态管理
self._query_in_progress = False       # 是否有查询在进行中
self._query_response_received = False # 是否收到查询响应
self._query_result = None             # 查询结果
self._current_query_type = None       # 当前查询类型
self._query_timeout = 200             # 默认查询超时时间（ms）

# 内部定时器
self._timer = Timer(-1)               # 用于周期性任务（如心跳检测、数据解析）

3.3.2 Class Attributes and Constants: Centralized Definition of Business Rules

3.3.2.1 Debug and Status Constants

# 是否启用调试（全局开关，便于日志输出与问题排查）
DEBUG_ENABLED = False

# 运动、呼吸、睡眠等状态的枚举映射
MOTION_NONE, MOTION_STATIC, MOTION_ACTIVE = (0x00, 0x01, 0x02)
BREATH_NORMAL, BREATH_HIGH, BREATH_LOW, BREATH_NONE = (0x01, 0x02, 0x03, 0x04)
BED_LEAVE, BED_ENTER, BED_NONE = (0x00, 0x01, 0x02)
SLEEP_DEEP, SLEEP_LIGHT, SLEEP_AWAKE, SLEEP_NONE = (0x00, 0x01, 0x02, 0x03)
# ... 其他状态枚举（如睡眠异常、质量评级等）

3.3.2.2 Instruction Type and Mapping Table

# 指令类型常量（区分查询、控制、设置操作）
TYPE_QUERY_HEARTBEAT = 0              # 心跳包查询
TYPE_MODULE_RESET = 1                 # 模组复位
TYPE_QUERY_PRODUCT_MODEL = 2          # 产品型号查询
# ... 人体存在、心率、呼吸、睡眠等模块的指令类型（共60+种）

# 指令映射表：将指令类型映射为“控制字、命令字、数据”的协议参数
COMMAND_MAP = {
    TYPE_QUERY_HEARTBEAT: {
        'control_byte': 0x01,
        'command_byte': 0x80,
        'data': bytes([0x0F])
    },
    # ... 其他指令的协议参数映射
}

# 查询类型到名称的映射（用于调试输出，提升日志可读性）
QUERY_NAME_MAP = {
    TYPE_QUERY_HEARTBEAT: "Heartbeat",
    TYPE_MODULE_RESET: "Module Reset",
    # ... 其他指令的名称映射
}

3.3.3 Private parsing method: conversion from raw data to business attributes

3.3.3.1 Human Body Position Analysis (Signed 16-bit Special Format)

def _parse_human_position_data(self, data_bytes):
    """解析人体方位数据（6字节：X(2B)、Y(2B)、Z(2B)），支持特殊符号位格式"""
    if len(data_bytes) != 6:
        return (0, 0, 0)
    x = self._parse_signed_16bit_special(data_bytes[0:2])
    y = self._parse_signed_16bit_special(data_bytes[2:4])
    z = self._parse_signed_16bit_special(data_bytes[4:6])
    return (x, y, z)

def _parse_signed_16bit_special(self, two_bytes):
    """解析特殊有符号16位数据（首位为符号位，后15位为数值）"""
    if len(two_bytes) != 2:
        return 0
    unsigned_value = (two_bytes[0] << 8) | two_bytes[1]
    sign_bit = (unsigned_value >> 15) & 0x1
    magnitude = unsigned_value & 0x7FFF
    return -magnitude if sign_bit else magnitude

3.3.3.2 Waveform Data Analysis (General Logic for Heart Rate and Respiration)

def _parse_heart_rate_waveform_data(self, data_bytes):
    """解析心率波形数据（5字节，还原实时波形数值）"""
    if len(data_bytes) != 5:
        return (128, 128, 128, 128, 128)
    return (data_bytes[0], data_bytes[1], data_bytes[2], data_bytes[3], data_bytes[4])

def _parse_breath_waveform_data(self, data_bytes):
    """解析呼吸波形数据（5字节，逻辑与心率波形一致）"""
    if len(data_bytes) != 5:
        return (128, 128, 128, 128, 128)
    return (data_bytes[0], data_bytes[1], data_bytes[2], data_bytes[3], data_bytes[4])

3.3.3.3 Sleep Data Analysis (Comprehensive Status and Statistical Information)

def _parse_sleep_comprehensive_data(self, data_bytes):
    """解析睡眠综合状态数据（8字节，多维度睡眠信息）"""
    if len(data_bytes) != 8:
        return (0, 0, 0, 0, 0, 0, 0, 0)
    return (
        data_bytes[0],  # 存在状态
        data_bytes[1],  # 睡眠状态
        data_bytes[2],  # 平均呼吸
        data_bytes[3],  # 平均心跳
        data_bytes[4],  # 翻身次数
        data_bytes[5],  # 大幅度体动占比
        data_bytes[6],  # 小幅度体动占比
        data_bytes[7]   # 呼吸暂停次数
    )

def _parse_sleep_statistics_data(self, data_bytes):
    """解析睡眠统计信息数据（12字节，时长、质量等汇总）"""
    if len(data_bytes) != 12:
        return (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
    total_sleep_duration = (data_bytes[1] << 8) | data_bytes[2]
    return (
        data_bytes[0],  # 睡眠质量评分
        total_sleep_duration,  # 睡眠总时长
        data_bytes[3],  # 清醒时长占比
        data_bytes[4],  # 浅睡时长占比
        data_bytes[5],  # 深睡时长占比
        data_bytes[6],  # 离床时长
        data_bytes[7],  # 离床次数
        data_bytes[8],  # 翻身次数
        data_bytes[9],  # 平均呼吸
        data_bytes[10], # 平均心跳
        data_bytes[11]  # 呼吸暂停次数
    )

3.3.3.4 Product and Firmware Information Parsing (String Processing)

def _parse_product_info_data(self, data_bytes):
    """解析产品信息（含空字节的字符串处理）"""
    try:
        if R60ABD1.DEBUG_ENABLED:
            print(f"[Parse] Raw product data: {data_bytes}, hex: {data_bytes.hex()}")
        # 截取空字节前的有效部分
        if b'\x00' in data_bytes:
            null_index = data_bytes.index(b'\x00')
            valid_data = data_bytes[:null_index]
        else:
            valid_data = data_bytes
        return (valid_data.decode('utf-8', errors='ignore').strip(),)
    except Exception as e:
        if R60ABD1.DEBUG_ENABLED:
            print(f"[Parse] Product info parse error: {e}, data: {data_bytes}")
        return ("",)

def _parse_firmware_version_data(self, data_bytes):
    """解析固件版本（逻辑与产品信息一致）"""
    try:
        if R60ABD1.DEBUG_ENABLED:
            print(f"[Parse] Raw firmware data: {data_bytes}, hex: {data_bytes.hex()}")
        if b'\x00' in data_bytes:
            null_index = data_bytes.index(b'\x00')
            valid_data = data_bytes[:null_index]
        else:
            valid_data = data_bytes
        return (valid_data.decode('utf-8', errors='ignore').strip(),)
    except Exception as e:
        if R60ABD1.DEBUG_ENABLED:
            print(f"[Parse] Firmware version parse error: {e}, data: {data_bytes}")
        return ("",)

3.3.4 Test and Verification of Parsing Logic: Correctness Validation in REPL Environment

# 模拟DataFlowProcessor（仅用于测试）
class MockDataProcessor:
    pass

# 初始化R60ABD1实例
device = R60ABD1(MockDataProcessor())

# 测试用例1：人体方位数据解析
human_position_data = bytes([0x80, 0x0F, 0x00, 0x2C, 0x00, 0x00])
result = device._parse_human_position_data(human_position_data)
print("人体方位数据:", result)
# 预期输出：(-32753, 44, 0) （验证符号位与数值的正确转换）

# 测试用例2：心率波形数据解析
heart_rate_waveform_data = bytes([0xC1, 0xBE, 0xAA, 0x90, 0x8A])
result = device._parse_heart_rate_waveform_data(heart_rate_waveform_data)
print("心率波形数据:", result)
# 预期输出：(193, 190, 170, 144, 138) （验证字节到数值的直接映射）

# 测试用例3：呼吸波形数据解析
breath_waveform_data = bytes([0xC9, 0x60, 0x18, 0x40, 0x9A])
result = device._parse_breath_waveform_data(breath_waveform_data)
print("呼吸波形数据:", result)
# 预期输出：(201, 96, 24, 64, 154) （逻辑与心率波形一致）

# 测试用例4：睡眠综合状态解析
sleep_comprehensive_data = bytes([0x01, 0x02, 0x12, 0x4B, 0x00, 0x26, 0x3E, 0x00])
result = device._parse_sleep_comprehensive_data(sleep_comprehensive_data)
print("睡眠综合状态数据:", result)
# 预期输出：(1, 2, 18, 75, 0, 38, 62, 0) （多维度睡眠信息的正确拆解）

# 测试用例5：睡眠统计信息解析
sleep_statistics_data = bytes([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
result = device._parse_sleep_statistics_data(sleep_statistics_data)
print("睡眠统计信息数据:", result)
# 预期输出：(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) （全零场景的兼容性）

3.3.5 update_properties_from_frame Method: Entry for Service Property Update

3.3.5.1 Objective of Method Design: The "Translator" from Data to Business

3.3.5.2 Hierarchical Strategy for Attribute Update Timing: Matching Data Frequency

3.3.5.3 Specific Implementation of the Method: Modularization Branch Parsing

# Python env   :
# -*- coding: utf-8 -*-
# @Time    : 2025/11/4 下午5:33
# @Author  : 李清水
# @File    : main.py
# @Description :

from machine import UART, Pin, Timer
import time
from data_flow_processor import DataFlowProcessor
import micropython

frame_count = 0

# 存储解析到的数据帧
parsed_frames_buffer = []

# 初始化UART0：TX=16, RX=17，波特率115200
uart = UART(0, baudrate=115200, tx=Pin(16), rx=Pin(17), timeout=0)

# 创建DataFlowProcessor实例
processor = DataFlowProcessor(uart)

# ======================================== 功能函数 ============================================

# 计时装饰器，用于计算函数运行时间
def timed_function(f: callable, *args: tuple, **kwargs: dict) -> callable:
    """
    计时装饰器，用于计算并打印函数/方法运行时间。

    Args:
        f (callable): 需要传入的函数/方法
        args (tuple): 函数/方法 f 传入的任意数量的位置参数
        kwargs (dict): 函数/方法 f 传入的任意数量的关键字参数

    Returns:
        callable: 返回计时后的函数
    """
    myname = str(f).split(' ')[1]

    def new_func(*args: tuple, **kwargs: dict) -> any:
        t: int = time.ticks_us()
        result = f(*args, **kwargs)
        delta: int = time.ticks_diff(time.ticks_us(), t)
        print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000))
        return result

    return new_func

def format_time():
    """格式化当前时间为 [YYYY-MM-DD HH:MM:SS.sss] 格式"""
    t = time.localtime()
    ms = time.ticks_ms() % 1000
    return f"[{t[0]}-{t[1]:02d}-{t[2]:02d} {t[3]:02d}:{t[4]:02d}:{t[5]:02d}.{ms:03d}]"

@timed_function
def timer_callback(timer):
    """定时器回调函数，每50ms触发一次，直接解析数据帧"""
    global frame_count, parsed_frames_buffer

    # 直接调用解析方法
    frames = processor.read_and_parse()

    # 将解析到的帧添加到缓冲区
    for frame in frames:
        frame_count += 1
        parsed_frames_buffer.append({
            'frame_number': frame_count,
            'control': frame['control_byte'],
            'command': frame['command_byte'],
            'data_length': frame['data_length'],
            'data_hex': frame['data'].hex() if frame['data'] else "",
            'raw_hex': frame['raw_data'].hex(),
            'timestamp': format_time()
        })

        # 更新属性
        micropython.schedule(update_properties_from_frame, frame)

@timed_function
def update_properties_from_frame(frame):
    """根据解析的帧更新属性值"""
    global heartbeat_last_received, presence_status, motion_status, movement_parameter
    global human_distance, human_position_x, human_position_y, human_position_z
    global breath_status, breath_value, breath_waveform
    global heart_rate_value, heart_rate_waveform
    global radar_in_range, system_initialized

    control = frame['control_byte']
    command = frame['command_byte']
    data = frame['data']
    current_time = time.ticks_ms()

    # 心跳包 (0x01)
    if control == 0x01 and command == 0x01:
        heartbeat_last_received = current_time
        print("[%s] Heartbeat received" % format_time())

    # 系统初始化状态 (0x05)
    elif control == 0x05 and command == 0x01:
        if data and len(data) > 0:
            system_initialized = (data[0] == 0x01)
            print("[%s] System initialized: %s" % (format_time(), "Yes" if system_initialized else "No"))

    # 雷达探测范围 (0x07)
    elif control == 0x07 and command == 0x07:
        if data and len(data) > 0:
            radar_in_range = (data[0] == 0x01)
            print("[%s] Radar in range: %s" % (format_time(), "Yes" if radar_in_range else "No"))

    # 人体存在状态 (0x80)
    elif control == 0x80:
        if command == 0x01:  # 存在信息
            if data and len(data) > 0:
                presence_status = data[0]
                status_text = "No one" if presence_status == 0 else "Someone"
                print("[%s] Presence status: %s" % (format_time(), status_text))

        elif command == 0x02:  # 运动信息
            if data and len(data) > 0:
                motion_status = data[0]
                status_text = ["No motion", "Static", "Active"][motion_status] if motion_status < 3 else "Unknown"
                print("[%s] Motion status: %s" % (format_time(), status_text))

        elif command == 0x03:  # 体动参数
            if data and len(data) > 0:
                movement_parameter = data[0]
                print("[%s] Movement parameter: %d" % (format_time(), movement_parameter))

        elif command == 0x04:  # 人体距离
            if data and len(data) >= 2:
                human_distance = data[0] | (data[1] << 8)
                print("[%s] Human distance: %d cm" % (format_time(), human_distance))

        elif command == 0x05:  # 人体方位
            if data and len(data) >= 6:
                human_position_x = data[0] | (data[1] << 8)
                human_position_y = data[2] | (data[3] << 8)
                human_position_z = data[4] | (data[5] << 8)
                print("[%s] Human position: X=%d, Y=%d, Z=%d" % (
                format_time(), human_position_x, human_position_y, human_position_z))

    # 呼吸监测 (0x81)
    elif control == 0x81:
        if command == 0x01:  # 呼吸状态
            if data and len(data) > 0:
                breath_status = data[0]
                status_text = ["Normal", "High", "Low", "None"][
                    breath_status - 1] if 1 <= breath_status <= 4 else "Unknown"
                print("[%s] Breath status: %s" % (format_time(), status_text))

        elif command == 0x02:  # 呼吸数值
            if data and len(data) > 0:
                breath_value = data[0]
                print("[%s] Breath value: %d" % (format_time(), breath_value))

        elif command == 0x05:  # 呼吸波形
            if data and len(data) >= 5:
                breath_waveform = list(data[:5])
                print("[%s] Breath waveform updated" % format_time())

    # 心率监测 (0x85)
    elif control == 0x85:
        if command == 0x02:  # 心率数值
            if data and len(data) > 0:
                heart_rate_value = data[0]
                print("[%s] Heart rate: %d" % (format_time(), heart_rate_value))

        elif command == 0x05:  # 心率波形
            if data and len(data) >= 5:
                heart_rate_waveform = list(data[:5])
                print("[%s] Heart rate waveform updated" % format_time())

# ======================================== 全局属性变量 ============================================

# 1. 系统级属性
heartbeat_last_received = 0
heartbeat_timeout_count = 0
heartbeat_interval = 0
system_initialized = False
system_initialized_timestamp = 0
module_reset_flag = False
module_reset_timestamp = 0
product_model = ""
product_id = ""
hardware_model = ""
firmware_version = ""

# 2. 雷达探测属性
radar_in_range = False
radar_in_range_timestamp = 0

# 3. 人体存在检测属性
presence_enabled = True
presence_status = 0
presence_status_timestamp = 0
motion_status = 0
motion_status_timestamp = 0
movement_parameter = 0
movement_parameter_timestamp = 0
human_distance = 0
human_distance_timestamp = 0
human_position_x = 0
human_position_y = 0
human_position_z = 0
human_position_timestamp = 0

# 4. 呼吸监测属性
breath_monitoring_enabled = True
breath_waveform_enabled = False
low_breath_threshold = 10
breath_status = 0
breath_status_timestamp = 0
breath_value = 0
breath_value_timestamp = 0
breath_waveform = [0, 0, 0, 0, 0]
breath_waveform_timestamp = 0

# 5. 心率监测属性
heart_rate_enabled = True
heart_rate_waveform_enabled = False
heart_rate_value = 0
heart_rate_value_timestamp = 0
heart_rate_waveform = [0, 0, 0, 0, 0]
heart_rate_waveform_timestamp = 0

# 6. 睡眠监测属性
sleep_monitoring_enabled = True
bed_status = 0
bed_status_timestamp = 0
sleep_status = 0
sleep_status_timestamp = 0
awake_duration = 0
light_sleep_duration = 0
deep_sleep_duration = 0
sleep_quality_score = 0
sleep_quality_rating = 0
sleep_comprehensive_status = {}
sleep_anomaly = 0
abnormal_struggle_status = 0
no_person_timing_status = 0
abnormal_struggle_enabled = False
no_person_timing_enabled = False
no_person_timing_duration = 30
sleep_cutoff_duration = 120
struggle_sensitivity = 1

# ======================================== 主程序 ============================================

# 初始化50ms定时器
timer = Timer(-1)
timer.init(period=50, mode=Timer.PERIODIC, callback=timer_callback)

# 测试计数器
test_counter = 0
last_print_time = time.ticks_ms()

try:
    while True:
        current_time = time.ticks_ms()

        # 检查是否需要打印缓冲区中的帧（每10个打印一次）
        if len(parsed_frames_buffer) >= 10:
            print("=====================================================")

            for frame_data in parsed_frames_buffer:
                print("[%s] Frame#%d: Control=0x%02X, Command=0x%02X, Length=%d, Data=%s" % (frame_data['timestamp'], frame_data['frame_number'], frame_data['control'], frame_data['command'], frame_data['data_length'], frame_data['data_hex']))
                print("[%s] Raw frame: %s" % (frame_data['timestamp'], frame_data['raw_hex']))
                print("-" * 60)

            print("=====================================================")

            # 清空缓冲区
            parsed_frames_buffer = []

        # 每5秒打印一次属性状态摘要
        if time.ticks_diff(current_time, last_print_time) >= 5000:

            last_print_time = current_time
            test_counter += 1

            print("[%s] Property Status Summary (Test #%d)" % (format_time(), test_counter))

            print("******************************************************************************************")

            # 系统状态
            print("System: Heartbeat=%d, Initialized=%s" % (
            heartbeat_last_received, "Yes" if system_initialized else "No"))

            # 雷达状态
            print("Radar: InRange=%s" % ("Yes" if radar_in_range else "No"))

            # 人体存在
            presence_text = "No one" if presence_status == 0 else "Someone"
            motion_text = ["No motion", "Static", "Active"][motion_status] if motion_status < 3 else "Unknown"
            print("Presence: Status=%s, Motion=%s, Distance=%dcm" % (presence_text, motion_text, human_distance))

            # 呼吸监测
            breath_status_text = ["Normal", "High", "Low", "None"][
                breath_status - 1] if 1 <= breath_status <= 4 else "Unknown"
            print("Breath: Status=%s, Value=%d" % (breath_status_text, breath_value))

            print("******************************************************************************************")

            # 心率监测
            print("Heart Rate: Value=%d" % heart_rate_value)

except KeyboardInterrupt:
    # 停止定时器
    timer.deinit()

    # 打印剩余未输出的帧
    if parsed_frames_buffer:
        print("=====================================================")
        print("[%s] Final output %d parsed frames:" % (format_time(), len(parsed_frames_buffer)))
        for frame_data in parsed_frames_buffer:
            print("[%s] Frame#%d: Control=0x%02X, Command=0x%02X, Length=%d, Data=%s" % (frame_data['timestamp'], frame_data['frame_number'], frame_data['control'], frame_data['command'], frame_data['data_length'], frame_data['data_hex']))
            print("[%s] Raw frame: %s" % (frame_data['timestamp'], frame_data['raw_hex']))
            print("-" * 60)

    # 输出最终统计信息
    stats = processor.get_stats()
    print("[%s] Final statistics:" % format_time())
    print("  Total bytes received: %d" % stats['total_bytes_received'])
    print("  Total frames parsed: %d" % stats['total_frames_parsed'])
    print("  CRC errors: %d" % stats['crc_errors'])
    print("  Frame errors: %d" % stats['frame_errors'])
    print("  Invalid frames: %d" % stats['invalid_frames'])

3.3.5.4 Performance Testing

def update_properties_from_frame(self, frame):
    """
    根据解析的帧更新属性值

    Args:
        frame: DataFlowProcessor解析后的帧数据字典
    """
    control = frame['control_byte']
    command = frame['command_byte']
    data = frame['data']

    # 心跳包 (0x01)
    if control == 0x01:
        # 心跳包上报
        if command == 0x01:
            self.heartbeat_last_received = time.ticks_ms()
            if R60ABD1.DEBUG_ENABLED:
                print("[Heartbeat] Received")

    # 系统初始化状态 (0x05)
    elif control == 0x05:
        if command == 0x01:  # 初始化完成信息
            if data and len(data) > 0:
                self.system_initialized = (data[0] == 0x01)
                self.system_initialized_timestamp = time.ticks_ms()
                if R60ABD1.DEBUG_ENABLED:
                    status = "completed" if self.system_initialized else "not completed"
                    print(f"[System] Initialization {status}")

    # 雷达探测范围 (0x07)
    elif control == 0x07:
        if command == 0x07:  # 位置越界状态上报
            if data and len(data) > 0:
                self.radar_in_range = (data[0] == 0x01)
                if R60ABD1.DEBUG_ENABLED:
                    status = "in range" if self.radar_in_range else "out of range"
                    print(f"[Radar] {status}")

    # 人体存在检测 (0x80)
    elif control == 0x80:
        if command == 0x01:  # 存在信息
            if data and len(data) > 0:
                self.presence_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = "No one" if self.presence_status == 0 else "Someone"
                    print(f"[Presence] {status_text}")

        elif command == 0x02:  # 运动信息
            if data and len(data) > 0:
                self.motion_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["No motion", "Static", "Active"][
                        self.motion_status] if self.motion_status < 3 else "Unknown"
                    print(f"[Motion] {status_text}")

        elif command == 0x03:  # 体动参数
            if data and len(data) > 0:
                self.movement_parameter = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Movement] Parameter: {self.movement_parameter}")

        elif command == 0x04:  # 人体距离
            if data and len(data) >= 2:
                self.human_distance = (data[0] << 8) | data[1]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Distance] {self.human_distance} cm")

        elif command == 0x05:  # 人体方位
            if data and len(data) == 6:
                x, y, z = self._parse_human_position_data(data)
                self.human_position_x = x
                self.human_position_y = y
                self.human_position_z = z
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Position] X={x}, Y={y}, Z={z}")

    # 呼吸监测 (0x81)
    elif control == 0x81:
        if command == 0x01:  # 呼吸状态
            if data and len(data) > 0:
                self.breath_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["Normal", "High", "Low", "None"][
                        self.breath_status - 1] if 1 <= self.breath_status <= 4 else "Unknown"
                    print(f"[Breath] Status: {status_text}")

        elif command == 0x02:  # 呼吸数值
            if data and len(data) > 0:
                self.breath_value = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Breath] Value: {self.breath_value}")

        elif command == 0x05:  # 呼吸波形
            if data and len(data) == 5:
                waveform = self._parse_breath_waveform_data(data)
                self.breath_waveform = list(waveform)
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Breath] Waveform updated: {waveform}")

    # 心率监测 (0x85)
    elif control == 0x85:
        if command == 0x02:  # 心率数值
            if data and len(data) > 0:
                self.heart_rate_value = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Heart Rate] Value: {self.heart_rate_value}")

        elif command == 0x05:  # 心率波形
            if data and len(data) == 5:
                waveform = self._parse_heart_rate_waveform_data(data)
                self.heart_rate_waveform = list(waveform)
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Heart Rate] Waveform updated: {waveform}")

    # 睡眠监测 (0x84)
    elif control == 0x84:
        if command == 0x01:  # 入床/离床状态
            if data and len(data) > 0:
                self.bed_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["Leave bed", "Enter bed", "None"][
                        self.bed_status] if self.bed_status < 3 else "Unknown"
                    print(f"[Bed] Status: {status_text}")

        elif command == 0x02:  # 睡眠状态
            if data and len(data) > 0:
                self.sleep_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["Deep sleep", "Light sleep", "Awake", "None"][
                        self.sleep_status] if self.sleep_status < 4 else "Unknown"
                    print(f"[Sleep] Status: {status_text}")

        elif command == 0x03:  # 清醒时长
            if data and len(data) >= 2:
                self.awake_duration = (data[0] << 8) | data[1]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Sleep] Awake duration: {self.awake_duration} min")

        elif command == 0x04:  # 浅睡时长
            if data and len(data) >= 2:
                self.light_sleep_duration = (data[0] << 8) | data[1]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Sleep] Light sleep duration: {self.light_sleep_duration} min")

        elif command == 0x05:  # 深睡时长
            if data and len(data) >= 2:
                self.deep_sleep_duration = (data[0] << 8) | data[1]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Sleep] Deep sleep duration: {self.deep_sleep_duration} min")

        elif command == 0x06:  # 睡眠质量评分
            if data and len(data) > 0:
                self.sleep_quality_score = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Sleep] Quality score: {self.sleep_quality_score}")

        elif command == 0x0C:  # 睡眠综合状态
            if data and len(data) == 8:
                comprehensive_data = self._parse_sleep_comprehensive_data(data)
                # 更新到字典属性
                self.sleep_comprehensive_status = {
                    'presence': comprehensive_data[0],
                    'sleep_status': comprehensive_data[1],
                    'avg_breath': comprehensive_data[2],
                    'avg_heart_rate': comprehensive_data[3],
                    'turnover_count': comprehensive_data[4],
                    'large_movement_ratio': comprehensive_data[5],
                    'small_movement_ratio': comprehensive_data[6],
                    'apnea_count': comprehensive_data[7]
                }
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Sleep] Comprehensive status updated")

        elif command == 0x0D:  # 睡眠质量分析/统计信息
            if data and len(data) == 12:
                stats_data = self._parse_sleep_statistics_data(data)
                # 更新对应的睡眠统计属性
                self.sleep_quality_score = stats_data[0]
                if R60ABD1.DEBUG_ENABLED:
                    # 注意：stats_data[1]是总睡眠时长，需要根据实际情况决定如何分配
                    print(f"[Sleep] Statistics updated")

        elif command == 0x0E:  # 睡眠异常
            if data and len(data) > 0:
                self.sleep_anomaly = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["Short sleep (<4h)", "Long sleep (>12h)", "No person anomaly", "Normal"][
                        self.sleep_anomaly] if self.sleep_anomaly < 4 else "Unknown"
                    print(f"[Sleep] Anomaly: {status_text}")

        elif command == 0x10:  # 睡眠质量评级
            if data and len(data) > 0:
                self.sleep_quality_rating = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["None", "Good", "Normal", "Poor"][
                        self.sleep_quality_rating] if self.sleep_quality_rating < 4 else "Unknown"
                    print(f"[Sleep] Quality rating: {status_text}")

        elif command == 0x11:  # 异常挣扎状态
            if data and len(data) > 0:
                self.abnormal_struggle_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["None", "Normal", "Abnormal"][
                        self.abnormal_struggle_status] if self.abnormal_struggle_status < 3 else "Unknown"
                    print(f"[Sleep] Struggle status: {status_text}")

        elif command == 0x12:  # 无人计时状态
            if data and len(data) > 0:
                self.no_person_timing_status = data[0]
                if R60ABD1.DEBUG_ENABLED:
                    status_text = ["None", "Normal", "Abnormal"][
                        self.no_person_timing_status] if self.no_person_timing_status < 3 else "Unknown"
                    print(f"[Sleep] No person timing: {status_text}")

# Python env   :
# -*- coding: utf-8 -*-
# @Time    : 2025/11/4 下午5:33
# @Author  : 李清水
# @File    : main.py
# @Description :

from machine import UART, Pin, Timer
import time
from data_flow_processor import DataFlowProcessor
from r60abd1 import R60ABD1, format_time

# 初始化UART0：TX=16, RX=17，波特率115200
uart = UART(0, baudrate=115200, tx=Pin(16), rx=Pin(17), timeout=0)

# 创建DataFlowProcessor实例
processor = DataFlowProcessor(uart)

# 创建R60ABD1实例
device = R60ABD1(processor, parse_interval=50)

# ======================================== 功能函数 ============================================

def print_sensor_data():
    """打印传感器数据到Thonny控制台"""
    print("=" * 50)
    print("%s Sensor Data" % format_time())
    print("=" * 50)

    # 心率数据
    print("Heart Rate: %d bpm" % device.heart_rate_value)
    print("Heart Rate Waveform: %s" % str(device.heart_rate_waveform))

    # 呼吸数据
    print("Breath Rate: %d bpm" % device.breath_value)
    print("Breath Status: %d" % device.breath_status)
    print("Breath Waveform: %s" % str(device.breath_waveform))

    # 人体存在数据
    print("Movement Parameter: %d" % device.movement_parameter)
    print("Presence Status: %s" % ("Someone" if device.presence_status == 1 else "No one"))
    print("Motion Status: %s" % ["No motion", "Static", "Active"][
        device.motion_status] if device.motion_status < 3 else "Unknown")

    # 距离和位置
    print("Human Distance: %d cm" % device.human_distance)
    print("Human Position: X=%d, Y=%d, Z=%d" % (
    device.human_position_x, device.human_position_y, device.human_position_z))

    # 雷达状态
    print("Radar in Range: %s" % ("Yes" if device.radar_in_range else "No"))

    print("=" * 50)

# ======================================== 主程序 ============================================

# 上次打印时间
last_print_time = time.ticks_ms()
print_interval = 2000  # 2秒打印一次

try:
    while True:
        current_time = time.ticks_ms()

        # 定期打印传感器数据
        if time.ticks_diff(current_time, last_print_time) >= print_interval:
            print_sensor_data()
            last_print_time = current_time

        # 小延迟，避免占用太多CPU
        time.sleep_ms(10)

except KeyboardInterrupt:
    print("%s Program interrupted by user" % format_time())

finally:
    # 清理资源
    print("%s Cleaning up resources..." % format_time())
    device.close()
    print("%s Program exited" % format_time())

3.3.5.5 Actual Operation Verification: Data Consistency and Visualization

3.3.6 Design and Implementation of Command Response Logic: Interactive Processing of Active Query/Setting/Enable Commands

3.3.6.1 Design Objectives and Core Ideas

3.3.6.2 Return Parameter Design Specification: A "Status + Result" Binary Tuple Mode Based on Device Response

3.3.6.2.1 Unified Format Requirements for Return Parameters

3.3.6.2.2 Core Judgment Basis: Equipment Response is the Only Data Source

3.3.6.2.3 Example of Return Parameters for Different Types of Instructions

def query_human_distance(self, timeout=200):
    """查询人体距离（遵循“状态+结果”二元组规范）"""
    return self._execute_operation(R60ABD1.TYPE_QUERY_HUMAN_DISTANCE, timeout=timeout)

# 实际执行逻辑（_execute_operation内部）：
# 1. 发送查询指令后，等待设备响应
# 2. 若收到响应：
#    - 校验控制字（0x80）、命令字（0x84）与指令匹配
#    - 从响应数据中解析距离值（(data[0] << 8) | data[1]）
#    - 返回 (True, 解析后的距离值)，同时更新self.human_distance
# 3. 若超时/响应不匹配：
#    - 返回 (False, None)，不修改任何属性

def enable_human_presence(self, timeout=200):
    """打开人体存在功能（遵循“状态+结果”二元组规范）"""
    return self._execute_operation(R60ABD1.TYPE_CONTROL_HUMAN_PRESENCE_ON, timeout=timeout)

# 实际执行逻辑：
# 1. 发送控制指令后，等待设备响应
# 2. 若收到响应：
#    - 校验控制字（0x80）、命令字（0x00）与指令匹配
#    - 从响应数据中解析开关状态（data[0] == 0x01 表示生效）
#    - 返回 (True, True)，同时更新self.presence_enabled = True
# 3. 若设备响应“未生效”（data[0] == 0x00）：
#    - 返回 (True, False)，self.presence_enabled = False
# 4. 若超时/响应异常：
#    - 返回 (False, None)，不修改属性

def set_low_breath_threshold(self, threshold, timeout=200):
    """设置低缓呼吸阈值（遵循“状态+结果”二元组规范）"""
    # 传入自定义配置数据，发送指令
    return self._execute_operation(
        R60ABD1.TYPE_SET_LOW_BREATH_THRESHOLD,
        data=bytes([threshold]),
        timeout=timeout
    )

# 实际执行逻辑：
# 1. 发送配置指令（携带自定义阈值）后，等待设备响应
# 2. 若收到响应：
#    - 校验控制字（0x81）、命令字（0x0B）与指令匹配
#    - 从响应数据中解析确认的阈值（data[0]）
#    - 返回 (True, 确认后的阈值)，同时更新self.low_breath_threshold
# 3. 若设备响应的阈值与发送值不一致：
#    - 返回 (True, 设备实际配置的阈值)，同步更新属性为设备确认值
# 4. 若超时/响应异常：
#    - 返回 (False, None)，不修改属性

3.3.6.2.4 Brief Overview

3.3.6.3 Implementation of Blocking Query Method: Taking Existence Information Query as an Example

class R60ABD1:
    def __init__(self, data_processor, **kwargs):
        # ... 其他属性初始化 ...
        # 查询状态管理
        self._query_in_progress = False  # 是否有查询在进行中
        self._query_response_received = False  # 是否收到响应
        self._query_result = None  # 查询结果
        self._current_query_type = None  # 当前查询类型
        self._query_timeout = 200  # 默认查询超时时间(ms)

    def query_presence_status(self, timeout=200):
        """
        查询存在信息状态（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 存在状态信息)
                - 查询状态: True-查询成功, False-查询失败
                - 存在状态信息: 0-无人, 1-有人 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            original_running = self._is_running
            self._is_running = False  # 临时禁用定时器，避免数据竞争

            # 初始化查询状态
            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_HUMAN_EXISTENCE_INFO

            # 构造查询指令帧
            header = bytes([0x53, 0x59])
            control = bytes([0x80])
            command = bytes([0x81])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)
            query_frame = crc_data + bytes([crc]) + bytes([0x54, 0x43])

            # 发送指令
            self.data_processor.uart.write(query_frame)
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Presence status query sent: {query_frame.hex()}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Presence status query timeout")
                    return False, None
                time.sleep_us(100)  # 微秒级延迟，避免CPU占用
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            return True, self._query_result
        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Presence status query error: {e}")
            return False, None
        finally:
            # 清理查询状态并恢复定时器
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None
            try:
                self._is_running = original_running
            except NameError:
                pass

    def query_heartbeat(self, timeout=200):
        """查询心跳包状态（阻塞式）"""
        # 逻辑与query_presence_status一致，仅指令类型和解析逻辑不同
        ...

    def query_product_model(self, timeout=200):
        """查询产品型号（阻塞式）"""
        ...

3.3.6.4 update_properties_from_frame Response Frame Processing Extension

def update_properties_from_frame(self, frame):
    control = frame['control_byte']
    command = frame['command_byte']
    data = frame['data']

    # ... 原有主动上报帧处理逻辑（系统、存在、呼吸、心率等）...

    # 人体存在检测（查询响应分支）
    elif control == 0x80 and command == 0x81:
        if data and len(data) > 0:
            presence_value = data[0]
            self.presence_status = presence_value

            # 匹配当前查询类型，更新查询结果
            if (self._query_in_progress and
                    self._current_query_type == R60ABD1.TYPE_QUERY_HUMAN_EXISTENCE_INFO and
                    not self._query_response_received):
                self._query_result = presence_value
                self._query_response_received = True
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Query] Presence status response: {'Someone' if presence_value else 'No one'}")

3.3.6.5 Test Verification: Compatibility of Query and Active Reporting

3.3.6.6 Design of Class Attribute Constants: The Mapping Bridge Between Protocols and Services

3.3.6.7 Extension and Verification of Basic Instruction Query Methods

def query_heartbeat(self, timeout=200):
    if self._query_in_progress:
        return False, None
    try:
        # 状态初始化与指令构造
        self._query_in_progress = True
        query_frame = bytes([0x53, 0x59, 0x01, 0x80, 0x00, 0x01, 0x0F, ...])  # 完整帧构造
        self.data_processor.uart.write(query_frame)
        # 响应等待与属性更新（通过update_properties_from_frame实现）
        start_time = time.ticks_ms()
        while not self._query_response_received:
            if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                return False, None
            time.sleep_us(100)
            frames = self.data_processor.read_and_parse()
            for frame in frames:
                self.update_properties_from_frame(frame)
        return True, self._query_result
    finally:
        # 状态清理
        self._query_in_progress = False

def update_properties_from_frame(self, frame):
    control = frame['control_byte']
    command = frame['command_byte']
    data = frame['data']

    # 心跳查询响应：更新心跳时间戳与查询结果
    if control == 0x01 and command == 0x80:
        self.heartbeat_last_received = time.ticks_ms()
        if self._query_in_progress and self._current_query_type == self.TYPE_QUERY_HEARTBEAT:
            self._query_result = True
            self._query_response_received = True

    # 产品型号查询响应：解析字符串并更新产品型号属性
    elif control == 0x02 and command == 0xA1:
        product_info = self._parse_product_info_data(data)[0]
        self.product_model = product_info
        if self._query_in_progress and self._current_query_type == self.TYPE_QUERY_PRODUCT_MODEL:
            self._query_result = product_info
            self._query_response_received = True
    # ... 其他指令响应分支同理扩展 ...

# Python env   :               
# -*- coding: utf-8 -*-        
# @Time    : 2025/11/4 下午5:35   
# @Author  : 李清水            
# @File    : r60abd1.py       
# @Description :

from machine import Timer
import time
import micropython

def format_time():
    """格式化当前时间为 [YYYY-MM-DD HH:MM:SS.sss] 格式"""
    t = time.localtime()
    ms = time.ticks_ms() % 1000
    return f"[{t[0]}-{t[1]:02d}-{t[2]:02d} {t[3]:02d}:{t[4]:02d}:{t[5]:02d}.{ms:03d}]"

# 计时装饰器，用于计算函数运行时间
def timed_function(f: callable, *args: tuple, **kwargs: dict) -> callable:
    """
    计时装饰器，用于计算并打印函数/方法运行时间。

    Args:
        f (callable): 需要传入的函数/方法
        args (tuple): 函数/方法 f 传入的任意数量的位置参数
        kwargs (dict): 函数/方法 f 传入的任意数量的关键字参数

    Returns:
        callable: 返回计时后的函数
    """
    myname = str(f).split(' ')[1]

    def new_func(*args: tuple, **kwargs: dict) -> any:
        t: int = time.ticks_us()
        result = f(*args, **kwargs)
        delta: int = time.ticks_diff(time.ticks_us(), t)
        print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000))
        return result

    return new_func

class R60ABD1:
    """
        R60ABD1雷达设备业务处理类
    """

    # 是否启用调试
    DEBUG_ENABLED = True

    # R60ABD1雷达设备业务处理类中各种状态值和配置选项的常量
    # 运动信息状态
    MOTION_NONE, MOTION_STATIC, MOTION_ACTIVE = (0x00, 0x01, 0x02)
    # 呼吸信息状态
    BREATH_NORMAL, BREATH_HIGH, BREATH_LOW, BREATH_NONE = (0x01, 0x02, 0x03, 0x04)
    # 床状态
    BED_LEAVE, BED_ENTER, BED_NONE = (0x00, 0x01, 0x02)
    # 睡眠状态
    SLEEP_DEEP, SLEEP_LIGHT, SLEEP_AWAKE, SLEEP_NONE = (0x00, 0x01, 0x02, 0x03)
    # 睡眠异常信息
    SLEEP_ANOMALY_NONE, SLEEP_ANOMALY_SHORT, SLEEP_ANOMALY_LONG, SLEEP_ANOMALY_NO_PERSON = (0x03, 0x00, 0x01, 0x02)
    # 睡眠质量级别
    SLEEP_QUALITY_NONE, SLEEP_QUALITY_GOOD, SLEEP_QUALITY_NORMAL, SLEEP_QUALITY_POOR = (0x00, 0x01, 0x02, 0x03)
    # 异常挣扎状态
    STRUGGLE_NONE, STRUGGLE_NORMAL, STRUGGLE_ABNORMAL = (0x00, 0x01, 0x02)
    # 无人计时状态
    NO_PERSON_TIMING_NONE, NO_PERSON_TIMING_NORMAL, NO_PERSON_TIMING_ABNORMAL = (0x00, 0x01, 0x02)
    # 挣扎状态判读灵敏度
    SENSITIVITY_LOW, SENSITIVITY_MEDIUM, SENSITIVITY_HIGH = (0x00, 0x01, 0x02)

    # R60ABD1雷达设备指令类型常量，用于标识不同的查询和控制操作
    # 基础指令信息查询和设置类型
    # 心跳包查询
    TYPE_QUERY_HEARTBEAT = 0
    # 模组复位指令
    TYPE_MODULE_RESET = 1
    # 产品型号查询
    TYPE_QUERY_PRODUCT_MODEL = 2
    # 产品 ID 查询
    TYPE_QUERY_PRODUCT_ID = 3
    # 硬件型号查询
    TYPE_QUERY_HARDWARE_MODEL = 4
    # 固件版本查询
    TYPE_QUERY_FIRMWARE_VERSION = 5
    # 初始化是否完成查询
    TYPE_QUERY_INIT_COMPLETE = 6
    # 雷达探测范围越界状态查询
    TYPE_QUERY_RADAR_RANGE_BOUNDARY = 7

    # 人体存在指令信息查询和设置类型
    # 打开人体存在功能
    TYPE_CONTROL_HUMAN_PRESENCE_ON = 8
    # 关闭人体存在功能
    TYPE_CONTROL_HUMAN_PRESENCE_OFF = 9
    # 查询人体存在开关状态
    TYPE_QUERY_HUMAN_PRESENCE_SWITCH = 10
    # 存在信息查询
    TYPE_QUERY_HUMAN_EXISTENCE_INFO = 11
    # 运动信息查询
    TYPE_QUERY_HUMAN_MOTION_INFO = 12
    # 体动参数查询
    TYPE_QUERY_HUMAN_BODY_MOTION_PARAM = 13
    # 人体距离查询
    TYPE_QUERY_HUMAN_DISTANCE = 14
    # 人体方位查询
    TYPE_QUERY_HUMAN_DIRECTION = 15

    # 心率监测指令信息查询和设置类型
    # 打开心率监测功能
    TYPE_CONTROL_HEART_RATE_MONITOR_ON = 16
    # 关闭心率监测功能
    TYPE_CONTROL_HEART_RATE_MONITOR_OFF = 17
    # 查询心率监测开关状态
    TYPE_QUERY_HEART_RATE_MONITOR_SWITCH = 18
    # 打开心率波形上报开关
    TYPE_CONTROL_HEART_RATE_WAVEFORM_REPORT_ON = 19
    # 关闭心率波形上报开关
    TYPE_CONTROL_HEART_RATE_WAVEFORM_REPORT_OFF = 20
    # 查询心率波形上报开关状态
    TYPE_QUERY_HEART_RATE_WAVEFORM_REPORT_SWITCH = 21
    # 心率数值查询
    TYPE_QUERY_HEART_RATE_VALUE = 22
    # 心率波形查询
    TYPE_QUERY_HEART_RATE_WAVEFORM = 23

    # 呼吸监测指令信息查询和设置类型
    # 打开呼吸监测功能
    TYPE_CONTROL_BREATH_MONITOR_ON = 24
    # 关闭呼吸监测功能
    TYPE_CONTROL_BREATH_MONITOR_OFF = 25
    # 查询呼吸监测开关状态
    TYPE_QUERY_BREATH_MONITOR_SWITCH = 26
    # 设置低缓呼吸判读阈值
    TYPE_SET_LOW_BREATH_THRESHOLD = 27
    # 查询低缓呼吸判读阈值
    TYPE_QUERY_LOW_BREATH_THRESHOLD = 28
    # 呼吸信息查询
    TYPE_QUERY_BREATH_INFO = 29
    # 呼吸数值查询
    TYPE_QUERY_BREATH_VALUE = 30
    # 打开呼吸波形上报开关
    TYPE_CONTROL_BREATH_WAVEFORM_REPORT_ON = 31
    # 关闭呼吸波形上报开关
    TYPE_CONTROL_BREATH_WAVEFORM_REPORT_OFF = 32
    # 查询呼吸波形上报开关状态
    TYPE_QUERY_BREATH_WAVEFORM_REPORT_SWITCH = 33
    # 呼吸波形查询
    TYPE_QUERY_BREATH_WAVEFORM = 34

    # 睡眠监测指令信息查询和设置类型
    # 打开睡眠监测功能
    TYPE_CONTROL_SLEEP_MONITOR_ON = 35
    # 关闭睡眠监测功能
    TYPE_CONTROL_SLEEP_MONITOR_OFF = 36
    # 查询睡眠监测开关状态
    TYPE_QUERY_SLEEP_MONITOR_SWITCH = 37
    # 打开异常挣扎状态监测
    TYPE_CONTROL_ABNORMAL_STRUGGLE_ON = 38
    # 关闭异常挣扎状态监测
    TYPE_CONTROL_ABNORMAL_STRUGGLE_OFF = 39
    # 查询异常挣扎状态开关
    TYPE_QUERY_ABNORMAL_STRUGGLE_SWITCH = 40
    # 查询异常挣扎状态
    TYPE_QUERY_ABNORMAL_STRUGGLE_STATUS = 41
    # 设置挣扎状态判读灵敏度
    TYPE_SET_STRUGGLE_SENSITIVITY = 42
    # 查询挣扎状态判读灵敏度
    TYPE_QUERY_STRUGGLE_SENSITIVITY = 43
    # 打开无人计时功能
    TYPE_CONTROL_NO_PERSON_TIMING_ON = 44
    # 关闭无人计时功能
    TYPE_CONTROL_NO_PERSON_TIMING_OFF = 45
    # 查询无人计时功能开关
    TYPE_QUERY_NO_PERSON_TIMING_SWITCH = 46
    # 设置无人计时时长
    TYPE_SET_NO_PERSON_TIMING_DURATION = 47
    # 查询无人计时时长
    TYPE_QUERY_NO_PERSON_TIMING_DURATION = 48
    # 设置睡眠截止时长
    TYPE_SET_SLEEP_END_DURATION = 49
    # 查询睡眠截止时长
    TYPE_QUERY_SLEEP_END_DURATION = 50
    # 入床/离床状态查询
    TYPE_QUERY_BED_STATUS = 51
    # 睡眠状态查询
    TYPE_QUERY_SLEEP_STATUS = 52
    # 清醒时长查询
    TYPE_QUERY_AWAKE_DURATION = 53
    # 浅睡时长查询
    TYPE_QUERY_LIGHT_SLEEP_DURATION = 54
    # 深睡时长查询
    TYPE_QUERY_DEEP_SLEEP_DURATION = 55
    # 睡眠质量评分查询
    TYPE_QUERY_SLEEP_QUALITY_SCORE = 56
    # 睡眠综合状态查询
    TYPE_QUERY_SLEEP_COMPREHENSIVE_STATUS = 57
    # 睡眠异常查询
    TYPE_QUERY_SLEEP_ANOMALY = 58
    # 睡眠统计查询
    TYPE_QUERY_SLEEP_STATISTICS = 59
    # 睡眠质量评级查询
    TYPE_QUERY_SLEEP_QUALITY_LEVEL = 60

    def __init__(self, data_processor, parse_interval=50,presence_enabled=True, heart_rate_enabled=True,
                 breath_monitoring_enabled=True, sleep_monitoring_enabled=True):
        """
        初始化R60ABD1实例

        Args:
            data_processor: DataFlowProcessor实例
            presence_enabled: 是否开启人体存在信息监测
            heart_rate_enabled: 是否开启心率监测
            breath_monitoring_enabled: 是否开启呼吸监测
            sleep_monitoring_enabled: 是否开启睡眠监测
        """
        if parse_interval > 200:
            raise ValueError("parse_interval must be less than 200ms")

        self.data_processor = data_processor
        self.parse_interval = parse_interval

        # 添加运行状态标志
        self._is_running = False

        # ============================ 1. 系统级属性 ============================

        # 心跳包监控
        self.heartbeat_last_received = 0  # 最后接收心跳包时间戳(ms)
        self.heartbeat_timeout_count = 0  # 心跳超时累计次数
        self.heartbeat_interval = 0  # 实际心跳间隔统计(ms)

        # 系统状态
        self.system_initialized = False  # 初始化完成状态(True/False)
        self.system_initialized_timestamp = 0  # 初始化完成时间戳(ms)
        self.module_reset_flag = False  # 模组复位状态标记
        self.module_reset_timestamp = 0  # 模组复位时间戳(ms)

        # 产品信息
        self.product_model = ""  # 产品型号(字符串)
        self.product_id = ""  # 产品ID(字符串)
        self.hardware_model = ""  # 硬件型号(字符串)
        self.firmware_version = ""  # 固件版本(字符串)

        # ============================ 2. 雷达探测属性 ============================

        # 位置状态
        self.radar_in_range = False  # 是否在探测范围内

        # ============================ 3. 人体存在检测属性 ============================

        # 基本状态
        self.presence_enabled = presence_enabled  # 人体存在功能开关

        # 存在状态
        self.presence_status = 0  # 0:无人, 1:有人

        # 运动状态
        self.motion_status = 0  # 0:无, 1:静止, 2:活跃

        # 量化数据
        self.movement_parameter = 0  # 体动参数(0-100)

        self.human_distance = 0  # 人体距离(0-65535 cm)

        self.human_position_x = 0  # X坐标(有符号)
        self.human_position_y = 0  # Y坐标(有符号)
        self.human_position_z = 0  # Z坐标(有符号)

        # ============================ 4. 呼吸监测属性 ============================

        # 功能配置
        self.breath_monitoring_enabled = breath_monitoring_enabled  # 呼吸监测开关
        self.breath_waveform_enabled = False  # 呼吸波形上报开关
        self.low_breath_threshold = 10  # 低缓呼吸阈值(10-20次/min)

        # 监测数据
        self.breath_status = 0  # 1:正常, 2:过高, 3:过低, 4:无
        self.breath_value = 0  # 呼吸数值(0-35次/分)
        self.breath_waveform = [0, 0, 0, 0, 0]  # 5个字节的波形数据

        # ============================ 5. 心率监测属性 ============================

        # 功能配置
        self.heart_rate_enabled = heart_rate_enabled  # 心率监测开关
        self.heart_rate_waveform_enabled = False  # 心率波形上报开关

        # 监测数据
        self.heart_rate_value = 0  # 心率数值(60-120)
        self.heart_rate_waveform = [0, 0, 0, 0, 0]  # 5个字节的波形数据

        # ============================ 6. 睡眠监测属性 ============================

        # 基础状态
        self.sleep_monitoring_enabled = sleep_monitoring_enabled  # 睡眠监测开关

        self.bed_status = 0  # 0:离床, 1:入床, 2:无
        self.sleep_status = 0  # 0:深睡, 1:浅睡, 2:清醒, 3:无

        # 时长统计
        self.awake_duration = 0  # 清醒时长(分钟)
        self.light_sleep_duration = 0  # 浅睡时长(分钟)
        self.deep_sleep_duration = 0  # 深睡时长(分钟)

        # 睡眠质量
        self.sleep_quality_score = 0  # 睡眠质量评分(0-100)
        self.sleep_quality_rating = 0  # 睡眠质量评级

        # 综合状态
        self.sleep_comprehensive_status = {}  # 包含8个字段的字典
        self.sleep_anomaly = 0  # 睡眠异常状态
        self.abnormal_struggle_status = 0  # 异常挣扎状态
        self.no_person_timing_status = 0  # 无人计时状态

        # 配置参数
        self.abnormal_struggle_enabled = False  # 异常挣扎开关
        self.no_person_timing_enabled = False  # 无人计时开关
        self.no_person_timing_duration = 30  # 无人计时时长
        self.sleep_cutoff_duration = 120  # 睡眠截止时长
        self.struggle_sensitivity = 1  # 挣扎灵敏度

        # 查询状态管理
        self._query_in_progress = False  # 是否有查询在进行中
        self._query_response_received = False  # 是否收到查询响应
        self._query_result = None  # 查询结果
        self._current_query_type = None  # 当前查询类型
        self._query_timeout = 200  # 默认查询超时时间(ms)

        self.timer = Timer(-1)
        self._start_timer()

    def _start_timer(self):
        """启动定时器"""
        self._is_running = True
        self.timer.init(period=self.parse_interval, mode=Timer.PERIODIC, callback=self._timer_callback)

    def _timer_callback(self, timer):
        """
        定时器回调函数，定期解析数据帧

        Args:
            timer: 定时器实例
        """
        if not self._is_running:
            return

        # 调用DataFlowProcessor的解析方法
        frames = self.data_processor.read_and_parse()

        # 对每个解析到的帧使用micropython.schedule进行异步处理
        for frame in frames:
            # 使用micropython.schedule安全地调用属性更新方法
            micropython.schedule(self.update_properties_from_frame, frame)

    def _calculate_crc(self, data_bytes):
        """
        计算CRC校验码
        校验码计算：帧头+控制字+命令字+长度标识+数据 求和后，取低八位

        Args:
            data_bytes: 字节序列或字节数组

        Returns:
            int: CRC校验码
        """
        return sum(data_bytes) & 0xFF

    def _parse_human_position_data(self, data_bytes):
        """
        解析人体方位数据 (6字节: X(2B), Y(2B), Z(2B))
        位置信息有正负：16位数据，最高位为符号位，剩余15位为数据位

        Returns:
            tuple: (x, y, z) 坐标值，单位cm
        """
        if len(data_bytes) != 6:
            return (0, 0, 0)

        x = self._parse_signed_16bit_special(data_bytes[0:2])
        y = self._parse_signed_16bit_special(data_bytes[2:4])
        z = self._parse_signed_16bit_special(data_bytes[4:6])

        return (x, y, z)

    def _parse_signed_16bit_special(self, two_bytes):
        """
        解析有符号16位数据（特殊格式：首位符号位 + 后15位数值位）
        最高位为符号位，0=正数，1=负数，剩余15位为数值

        Args:
            two_bytes: 2字节的字节序列（大端序）

        Returns:
            int: 有符号16位整数
        """
        if len(two_bytes) != 2:
            return 0

        # 组合成16位无符号整数（大端序）
        unsigned_value = (two_bytes[0] << 8) | two_bytes[1]

        # 提取符号位和数值
        sign_bit = (unsigned_value >> 15) & 0x1  # 最高位为符号位
        magnitude = unsigned_value & 0x7FFF      # 低15位为数值

        # 根据符号位确定正负
        if sign_bit == 1:  # 负数
            return -magnitude
        else:  # 正数
            return magnitude

    def _parse_heart_rate_waveform_data(self, data_bytes):
        """
        解析心率波形数据 (5字节)
        5个字节代表实时1s内5个数值，波形为正弦波数据，中轴线为128

        Returns:
            tuple: 5个波形数据值 (v1, v2, v3, v4, v5)，数值范围0-255
        """
        if len(data_bytes) != 5:
            return (128, 128, 128, 128, 128)

        return (
            data_bytes[0],
            data_bytes[1],
            data_bytes[2],
            data_bytes[3],
            data_bytes[4]
        )

    def _parse_sleep_comprehensive_data(self, data_bytes):
        """
        解析睡眠综合状态数据 (8字节)

        Returns:
            tuple: (存在, 睡眠状态, 平均呼吸, 平均心跳, 翻身次数, 大幅度体动占比, 小幅度体动占比, 呼吸暂停次数)
        """
        if len(data_bytes) != 8:
            return (0, 0, 0, 0, 0, 0, 0, 0)

        return (
            data_bytes[0],  # 存在: 1有人 0无人
            data_bytes[1],  # 睡眠状态: 3离床 2清醒 1浅睡 0深睡
            data_bytes[2],  # 平均呼吸: 10分钟内检测的平均值
            data_bytes[3],  # 平均心跳: 10分钟内检测的平均值
            data_bytes[4],  # 翻身次数: 处于浅睡或深睡的翻身次数
            data_bytes[5],  # 大幅度体动占比: 0~100
            data_bytes[6],  # 小幅度体动占比: 0~100
            data_bytes[7]  # 呼吸暂停次数: 10分钟呼吸暂停次数
        )

    def _parse_sleep_statistics_data(self, data_bytes):
        """
        解析睡眠统计信息数据 (12字节)

        Returns:
            tuple: (睡眠质量评分, 睡眠总时长, 清醒时长占比, 浅睡时长占比, 深睡时长占比,
                   离床时长, 离床次数, 翻身次数, 平均呼吸, 平均心跳, 呼吸暂停次数)
        """
        if len(data_bytes) != 12:
            return (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        # 解析2字节的睡眠总时长
        total_sleep_duration = (data_bytes[1] << 8) | data_bytes[2]

        return (
            data_bytes[0],  # 睡眠质量评分: 0~100
            total_sleep_duration,  # 睡眠总时长: 0~65535分钟
            data_bytes[3],  # 清醒时长占比: 0~100
            data_bytes[4],  # 浅睡时长占比: 0~100
            data_bytes[5],  # 深睡时长占比: 0~100
            data_bytes[6],  # 离床时长: 0~255
            data_bytes[7],  # 离床次数: 0~255
            data_bytes[8],  # 翻身次数: 0~255
            data_bytes[9],  # 平均呼吸: 0~25
            data_bytes[10],  # 平均心跳: 0~100
            data_bytes[11]  # 呼吸暂停次数: 0~10
        )

    def _parse_breath_waveform_data(self, data_bytes):
        """
        解析呼吸波形数据 (5字节)
        5个字节代表实时1s内5个数值，波形为正弦波数据，中轴线为128

        Returns:
            tuple: 5个波形数据值 (v1, v2, v3, v4, v5)，数值范围0-255
        """
        if len(data_bytes) != 5:
            return (128, 128, 128, 128, 128)

        return (
            data_bytes[0],
            data_bytes[1],
            data_bytes[2],
            data_bytes[3],
            data_bytes[4]
        )

    def _parse_product_info_data(self, data_bytes):
        """
        解析产品信息数据 (可变长度字符串)
        正确处理包含空字节的字符串
        """
        try:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Parse] Raw product data: {data_bytes}, hex: {data_bytes.hex()}")

            # 找到第一个空字节的位置，截取有效部分
            if b'\x00' in data_bytes:
                # 找到第一个空字节，截取之前的部分
                null_index = data_bytes.index(b'\x00')
                valid_data = data_bytes[:null_index]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Parse] After null removal: {valid_data}, hex: {valid_data.hex()}")
            else:
                valid_data = data_bytes

            # 解码为字符串 - 移除关键字参数
            # MicroPython 的 decode 方法不支持 errors='ignore' 关键字参数
            product_info = valid_data.decode('utf-8').strip()
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Parse] Decoded product info: '{product_info}'")

            return (product_info,)
        except Exception as e:
            # 如果解码失败，尝试其他方式
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Parse] Product info parse error: {e}, data: {data_bytes}")

            # 尝试使用 ascii 解码作为备选方案
            try:
                product_info = valid_data.decode('ascii').strip()
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Parse] ASCII decoded product info: '{product_info}'")
                return (product_info,)
            except:
                return ("",)

    def _parse_firmware_version_data(self, data_bytes):
        """
        解析固件版本数据 (可变长度字符串)
        正确处理包含空字节的字符串
        """
        try:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Parse] Raw firmware data: {data_bytes}, hex: {data_bytes.hex()}")

            # 找到第一个空字节的位置，截取有效部分
            if b'\x00' in data_bytes:
                # 找到第一个空字节，截取之前的部分
                null_index = data_bytes.index(b'\x00')
                valid_data = data_bytes[:null_index]
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Parse] After null removal: {valid_data}, hex: {valid_data.hex()}")
            else:
                valid_data = data_bytes

            # 解码为字符串 - 移除关键字参数
            version = valid_data.decode('utf-8').strip()
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Parse] Decoded firmware version: '{version}'")

            return (version,)
        except Exception as e:
            # 如果解码失败，尝试其他方式
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Parse] Firmware version parse error: {e}, data: {data_bytes}")

            # 尝试使用 ascii 解码作为备选方案
            try:
                version = valid_data.decode('ascii').strip()
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Parse] ASCII decoded firmware version: '{version}'")
                return (version,)
            except:
                return ("",)

    def query_heartbeat(self, timeout=200):
        """
        查询心跳包（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 心跳状态)
                - 查询状态: True-查询成功, False-查询失败
                - 心跳状态: True-心跳正常, False-心跳异常 (查询成功时有效)
        """
        # 检查查询状态，避免多个查询同时进行
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            # 保存原始定时器状态并临时禁用定时器，避免数据竞争
            original_running = self._is_running
            self._is_running = False

            # 设置查询状态标志
            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_HEARTBEAT

            # 构造心跳包查询指令帧
            header = bytes([0x53, 0x59])  # 帧头
            control = bytes([0x01])  # 控制字：系统指令
            command = bytes([0x80])  # 命令字：心跳包查询
            length = bytes([0x00, 0x01])  # 数据长度：1字节
            data = bytes([0x0F])  # 固定数据

            # 计算CRC校验码
            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])  # 帧尾
            query_frame = crc_data + bytes([crc]) + trailer

            # 发送查询指令
            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Heartbeat query sent")
                # 打印发送的指令帧用于调试
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待设备响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                # 检查是否超时
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Heartbeat query timeout")
                    return False, None

                # 短暂延迟避免过度占用CPU
                time.sleep_us(100)

                # 继续处理数据流，确保响应能被解析
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            # 返回查询结果：成功状态和心跳状态
            return True, self._query_result

        except Exception as e:
            # 异常处理：打印错误信息并返回失败状态
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Heartbeat query error: {e}")
            return False, None
        finally:
            # 清理查询状态，确保资源正确释放
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            # 恢复定时器状态
            try:
                self._is_running = original_running
            except NameError:
                pass  # 如果original_running未定义，保持当前状态

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Heartbeat query state reset")

    def reset_module(self, timeout=500):
        """
        模组复位（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒（复位需要较长时间，默认500ms）

        Returns:
            bool: True-复位成功, False-复位失败
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False

        try:
            # 保存原始定时器状态并临时禁用定时器
            original_running = self._is_running
            self._is_running = False

            # 设置复位查询状态
            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_MODULE_RESET

            # 构造模组复位指令帧
            header = bytes([0x53, 0x59])  # 帧头
            control = bytes([0x01])  # 控制字：系统指令
            command = bytes([0x02])  # 命令字：模组复位
            length = bytes([0x00, 0x01])  # 数据长度：1字节
            data = bytes([0x0F])  # 固定数据

            # 计算CRC校验码
            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])  # 帧尾
            query_frame = crc_data + bytes([crc]) + trailer

            # 发送复位指令
            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Module reset command sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待复位响应（设备会原样返回指令作为确认）
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Module reset timeout")
                    return False

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            # 返回复位结果
            return self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Module reset error: {e}")
            return False
        finally:
            # 清理查询状态
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            # 恢复定时器状态
            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Module reset state reset")

    def query_product_model(self, timeout=200):
        """
        查询产品型号（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 产品型号)
                - 查询状态: True-查询成功, False-查询失败
                - 产品型号: 字符串 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            # 保存原始定时器状态并临时禁用定时器
            original_running = self._is_running
            self._is_running = False

            # 设置产品型号查询状态
            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_PRODUCT_MODEL

            # 构造产品型号查询指令帧
            header = bytes([0x53, 0x59])  # 帧头
            control = bytes([0x02])  # 控制字：产品信息
            command = bytes([0xA1])  # 命令字：产品型号查询
            length = bytes([0x00, 0x01])  # 数据长度：1字节
            data = bytes([0x0F])  # 固定数据

            # 计算CRC校验码
            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])  # 帧尾
            query_frame = crc_data + bytes([crc]) + trailer

            # 发送查询指令
            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Product model query sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待产品型号响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Product model query timeout")
                    return False, None

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            # 返回查询结果：成功状态和产品型号字符串
            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Product model query error: {e}")
            return False, None
        finally:
            # 清理查询状态
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            # 恢复定时器状态
            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Product model query state reset")

    def query_product_id(self, timeout=200):
        """
        查询产品ID（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 产品ID)
                - 查询状态: True-查询成功, False-查询失败
                - 产品ID: 字符串 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            original_running = self._is_running
            self._is_running = False

            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_PRODUCT_ID

            # 构造产品ID查询指令
            header = bytes([0x53, 0x59])
            control = bytes([0x02])
            command = bytes([0xA2])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])
            query_frame = crc_data + bytes([crc]) + trailer

            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Product ID query sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Product ID query timeout")
                    return False, None

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Product ID query error: {e}")
            return False, None
        finally:
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Product ID query state reset")

    def query_hardware_model(self, timeout=200):
        """
        查询硬件型号（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 硬件型号)
                - 查询状态: True-查询成功, False-查询失败
                - 硬件型号: 字符串 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            original_running = self._is_running
            self._is_running = False

            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_HARDWARE_MODEL

            # 构造硬件型号查询指令
            header = bytes([0x53, 0x59])
            control = bytes([0x02])
            command = bytes([0xA3])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])
            query_frame = crc_data + bytes([crc]) + trailer

            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Hardware model query sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Hardware model query timeout")
                    return False, None

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Hardware model query error: {e}")
            return False, None
        finally:
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Hardware model query state reset")

    def query_firmware_version(self, timeout=200):
        """
        查询固件版本（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 固件版本)
                - 查询状态: True-查询成功, False-查询失败
                - 固件版本: 字符串 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            original_running = self._is_running
            self._is_running = False

            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_FIRMWARE_VERSION

            # 构造固件版本查询指令
            header = bytes([0x53, 0x59])
            control = bytes([0x02])
            command = bytes([0xA4])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])
            query_frame = crc_data + bytes([crc]) + trailer

            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Firmware version query sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Firmware version query timeout")
                    return False, None

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Firmware version query error: {e}")
            return False, None
        finally:
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Firmware version query state reset")

    def query_init_complete(self, timeout=200):
        """
        查询初始化是否完成（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 初始化状态)
                - 查询状态: True-查询成功, False-查询失败
                - 初始化状态: True-已完成, False-未完成 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            original_running = self._is_running
            self._is_running = False

            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_INIT_COMPLETE

            # 构造初始化完成查询指令
            header = bytes([0x53, 0x59])
            control = bytes([0x05])
            command = bytes([0x81])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])
            query_frame = crc_data + bytes([crc]) + trailer

            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Init complete query sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Init complete query timeout")
                    return False, None

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Init complete query error: {e}")
            return False, None
        finally:
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Init complete query state reset")

    def query_radar_range_boundary(self, timeout=200):
        """
        查询雷达探测范围越界状态（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 越界状态)
                - 查询状态: True-查询成功, False-查询失败
                - 越界状态: True-越界, False-正常范围内 (查询成功时有效)
        """
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            original_running = self._is_running
            self._is_running = False

            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_RADAR_RANGE_BOUNDARY

            # 构造雷达探测范围查询指令
            header = bytes([0x53, 0x59])
            control = bytes([0x07])
            command = bytes([0x87])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])
            query_frame = crc_data + bytes([crc]) + trailer

            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Radar range boundary query sent")
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Radar range boundary query timeout")
                    return False, None

                time.sleep_us(100)
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Radar range boundary query error: {e}")
            return False, None
        finally:
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            try:
                self._is_running = original_running
            except NameError:
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Radar range boundary query state reset")

    def query_presence_status(self, timeout=200):
        """
        查询存在信息状态（阻塞式）

        Args:
            timeout: 超时时间，单位毫秒

        Returns:
            tuple: (查询状态, 存在状态信息)
                - 查询状态: True-查询成功, False-查询失败
                - 存在状态信息: 0-无人, 1-有人 (查询成功时有效)
        """
        # 检查是否已有查询在进行中
        if self._query_in_progress:
            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Another query in progress, aborting")
            return False, None

        try:
            # 临时禁用定时器回调，避免竞争
            original_running = self._is_running
            self._is_running = False

            # 设置查询状态
            self._query_in_progress = True
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = R60ABD1.TYPE_QUERY_HUMAN_EXISTENCE_INFO

            # 构造并发送查询指令
            header = bytes([0x53, 0x59])
            control = bytes([0x80])
            command = bytes([0x81])
            length = bytes([0x00, 0x01])
            data = bytes([0x0F])

            crc_data = header + control + command + length + data
            crc = self._calculate_crc(crc_data)

            trailer = bytes([0x54, 0x43])

            query_frame = crc_data + bytes([crc]) + trailer

            self.data_processor.uart.write(query_frame)

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Presence status query sent")
                # 调试信息：打印发送的指令
                frame_hex = ' '.join(['{:02X}'.format(b) for b in query_frame])
                print(f"[Query] Sent frame: {frame_hex}")

            # 等待响应
            start_time = time.ticks_ms()
            while not self._query_response_received:
                # 检查超时
                if time.ticks_diff(time.ticks_ms(), start_time) >= timeout:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Presence status query timeout")
                    return False, None

                # 短暂延迟，避免完全占用CPU
                time.sleep_us(100)

                # 继续处理数据流（确保响应能被解析）
                frames = self.data_processor.read_and_parse()
                for frame in frames:
                    self.update_properties_from_frame(frame)

            # 返回查询结果
            return True, self._query_result

        except Exception as e:
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Query] Presence status query error: {e}")
            return False, None
        finally:
            # 重置所有查询状态
            self._query_in_progress = False
            self._query_response_received = False
            self._query_result = None
            self._current_query_type = None

            # 安全地恢复定时器状态
            try:
                self._is_running = original_running
            except NameError:
                # 如果 original_running 未定义，保持定时器运行状态不变
                pass

            if R60ABD1.DEBUG_ENABLED:
                print("[Query] Query state reset")
    def update_properties_from_frame(self, frame):
        """
        根据解析的帧更新属性值

        Args:
            frame: DataFlowProcessor解析后的帧数据字典
        """
        control = frame['control_byte']
        command = frame['command_byte']
        data = frame['data']

        # 心跳包 (0x01)
        if control == 0x01:
            # 心跳包上报
            if command == 0x01:
                self.heartbeat_last_received = time.ticks_ms()
                if R60ABD1.DEBUG_ENABLED:
                    print("[Heartbeat] Received")
            # 心跳包查询响应
            elif command == 0x80:
                # 更新心跳包最后接收时间
                self.heartbeat_last_received = time.ticks_ms()

                # 处理心跳包查询响应
                if (self._query_in_progress and
                        self._current_query_type == R60ABD1.TYPE_QUERY_HEARTBEAT and
                        not self._query_response_received):

                    # 设置查询结果为心跳正常
                    self._query_result = True
                    self._query_response_received = True

                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Heartbeat response received")

                # 当前正在进行其他类型的查询，但收到了心跳包响应
                elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_HEARTBEAT:
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Heartbeat] Unexpected query response during {self._current_query_type} query")

                # 没有查询在进行，但收到了查询响应
                elif not self._query_in_progress:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Heartbeat] Unsolicited query response")

            # 模组复位响应
            elif command == 0x02:
                # 模组复位成功，设备原样返回指令作为确认
                if (self._query_in_progress and
                        self._current_query_type == R60ABD1.TYPE_MODULE_RESET and
                        not self._query_response_received):

                    # 更新模组复位状态和时间戳
                    self.module_reset_flag = True
                    self.module_reset_timestamp = time.ticks_ms()
                    self._query_result = True  # 复位成功
                    self._query_response_received = True

                    if R60ABD1.DEBUG_ENABLED:
                        print("[Query] Module reset response received")

                # 当前正在进行其他类型的查询，但收到了模组复位响应
                elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_MODULE_RESET:
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Reset] Unexpected query response during {self._current_query_type} query")

                # 没有查询在进行，但收到了查询响应
                elif not self._query_in_progress:
                    if R60ABD1.DEBUG_ENABLED:
                        print("[Reset] Unsolicited query response")

        # 产品信息指令 (0x02)
        elif control == 0x02:
            # 产品型号查询响应
            if command == 0xA1:
                if data:
                    # 解析产品型号数据
                    product_info = self._parse_product_info_data(data)[0]
                    # 更新产品型号属性
                    self.product_model = product_info

                    # 处理产品型号查询响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_PRODUCT_MODEL and
                            not self._query_response_received):

                        # 设置查询结果为产品型号字符串
                        self._query_result = product_info
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Query] Product model response: {product_info}")

                    # 当前正在进行其他类型的查询，但收到了产品型号响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_PRODUCT_MODEL:
                        if R60ABD1.DEBUG_ENABLED:
                            print(
                                f"[Product Model] Unexpected query response during {self._current_query_type} query: {product_info}")

                    # 没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Product Model] Unsolicited query response: {product_info}")

            # 产品ID查询响应
            elif command == 0xA2:
                if data:
                    # 解析产品ID数据
                    product_id = self._parse_product_info_data(data)[0]
                    # 更新产品ID属性
                    self.product_id = product_id

                    print(product_id)

                    # 处理产品ID查询响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_PRODUCT_ID and
                            not self._query_response_received):

                        # 设置查询结果为产品ID字符串
                        self._query_result = product_id
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Query] Product ID response: {product_id}")

                    # 当前正在进行其他类型的查询，但收到了产品ID响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_PRODUCT_ID:
                        if R60ABD1.DEBUG_ENABLED:
                            print(
                                f"[Product ID] Unexpected query response during {self._current_query_type} query: {product_id}")

                    # 没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Product ID] Unsolicited query response: {product_id}")
            # 硬件型号查询响应
            elif command == 0xA3:
                if data:
                    # 解析硬件型号数据
                    hardware_model = self._parse_product_info_data(data)[0]
                    # 更新硬件型号属性
                    self.hardware_model = hardware_model

                    print(hardware_model)

                    # 处理硬件型号查询响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_HARDWARE_MODEL and
                            not self._query_response_received):

                        # 设置查询结果为硬件型号字符串
                        self._query_result = hardware_model
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Query] Hardware model response: {hardware_model}")

                    # 当前正在进行其他类型的查询，但收到了硬件型号响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_HARDWARE_MODEL:
                        if R60ABD1.DEBUG_ENABLED:
                            print(
                                f"[Hardware Model] Unexpected query response during {self._current_query_type} query: {hardware_model}")

                    # 没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Hardware Model] Unsolicited query response: {hardware_model}")

            # 固件版本查询响应
            elif command == 0xA4:
                if data:
                    # 解析固件版本数据
                    firmware_version = self._parse_firmware_version_data(data)[0]
                    # 更新固件版本属性
                    self.firmware_version = firmware_version

                    print(firmware_version)

                    # 处理固件版本查询响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_FIRMWARE_VERSION and
                            not self._query_response_received):

                        # 设置查询结果为固件版本字符串
                        self._query_result = firmware_version
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Query] Firmware version response: {firmware_version}")

                    # 当前正在进行其他类型的查询，但收到了固件版本响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_FIRMWARE_VERSION:
                        if R60ABD1.DEBUG_ENABLED:
                            print(
                                f"[Firmware] Unexpected query response during {self._current_query_type} query: {firmware_version}")

                    # 没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            print(f"[Firmware] Unsolicited query response: {firmware_version}")

        # 系统初始化状态 (0x05)
        elif control == 0x05:
            # 初始化完成信息
            if command == 0x01:
                if data and len(data) > 0:
                    self.system_initialized = (data[0] == 0x01)
                    self.system_initialized_timestamp = time.ticks_ms()
                    if R60ABD1.DEBUG_ENABLED:
                        status = "completed" if self.system_initialized else "not completed"
                        print(f"[System] Initialization {status}")

            # 初始化完成查询响应
            elif command == 0x81:
                if data and len(data) > 0:
                    # 解析初始化状态：0x01表示已完成
                    init_status = (data[0] == 0x01)
                    # 更新系统初始化状态
                    self.system_initialized = init_status

                    # 处理初始化完成查询响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_INIT_COMPLETE and
                            not self._query_response_received):

                        # 设置查询结果为初始化状态
                        self._query_result = init_status
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "completed" if init_status else "not completed"
                            print(f"[Query] Init complete response: {status_text}")

                    # 当前正在进行其他类型的查询，但收到了初始化完成响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_INIT_COMPLETE:
                        status_text = "completed" if init_status else "not completed"
                        if R60ABD1.DEBUG_ENABLED:
                            print(
                                f"[Init Complete] Unexpected query response during {self._current_query_type} query: {status_text}")

                    # 没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "completed" if init_status else "not completed"
                            print(f"[Init Complete] Unsolicited query response: {status_text}")

        # 雷达探测范围 (0x07)
        elif control == 0x07:
            # 位置越界状态上报
            if command == 0x07:
                if data and len(data) > 0:
                    self.radar_in_range = (data[0] == 0x01)
                    if R60ABD1.DEBUG_ENABLED:
                        status = "in range" if self.radar_in_range else "out of range"
                        print(f"[Radar] {status}")
            # 位置越界状态查询响应
            elif command == 0x87:
                if data and len(data) > 0:
                    # 解析越界状态：0x01表示越界
                    boundary_status = (data[0] == 0x01)
                    # 更新雷达探测范围状态（越界表示不在范围内）
                    self.radar_in_range = not boundary_status

                    # 处理雷达探测范围查询响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_RADAR_RANGE_BOUNDARY and
                            not self._query_response_received):

                        # 设置查询结果为越界状态（True表示越界）
                        self._query_result = boundary_status
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "out of range" if boundary_status else "in range"
                            print(f"[Query] Radar range boundary response: {status_text}")

                    # 当前正在进行其他类型的查询，但收到了雷达范围响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_RADAR_RANGE_BOUNDARY:
                        status_text = "out of range" if boundary_status else "in range"
                        if R60ABD1.DEBUG_ENABLED:
                            print(
                                f"[Radar Range] Unexpected query response during {self._current_query_type} query: {status_text}")

                    # 没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "out of range" if boundary_status else "in range"
                            print(f"[Radar Range] Unsolicited query response: {status_text}")

        # 人体存在检测 (0x80)
        elif control == 0x80:
            if command == 0x01:  # 存在信息
                if data and len(data) > 0:
                    self.presence_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = "No one" if self.presence_status == 0 else "Someone"
                        print(f"[Presence] {status_text}")

            elif command == 0x81:  # 存在信息（查询响应）
                if data and len(data) > 0:
                    presence_value = data[0]

                    # 更新属性
                    self.presence_status = presence_value

                    # 处理查询响应
                    # 情况1：当前正在进行存在信息查询，且尚未收到响应
                    if (self._query_in_progress and
                            self._current_query_type == R60ABD1.TYPE_QUERY_HUMAN_EXISTENCE_INFO and
                            not self._query_response_received):

                        self._query_result = presence_value
                        self._query_response_received = True

                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "No one" if presence_value == 0 else "Someone"
                            print(f"[Query] Presence status response: {status_text}")

                    # 情况2：当前正在进行其他类型的查询，但收到了存在信息响应
                    elif self._query_in_progress and self._current_query_type != R60ABD1.TYPE_QUERY_HUMAN_EXISTENCE_INFO:
                        status_text = "No one" if presence_value == 0 else "Someone"
                        print(f"[Presence] Unexpected query response during {self._current_query_type} query: {status_text}")

                    # 情况3：没有查询在进行，但收到了查询响应
                    elif not self._query_in_progress:
                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "No one" if presence_value == 0 else "Someone"
                            print(f"[Presence] Unsolicited query response: {status_text}")

                    # 情况4：其他情况（理论上不应该到达这里）
                    else:
                        if R60ABD1.DEBUG_ENABLED:
                            status_text = "No one" if presence_value == 0 else "Someone"
                            print(f"[Presence] Unexpected state in query response handling, query response: {status_text}")

            elif command == 0x02:  # 运动信息
                if data and len(data) > 0:
                    self.motion_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["No motion", "Static", "Active"][
                            self.motion_status] if self.motion_status < 3 else "Unknown"
                        print(f"[Motion] {status_text}")

            elif command == 0x03:  # 体动参数
                if data and len(data) > 0:
                    self.movement_parameter = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Movement] Parameter: {self.movement_parameter}")

            elif command == 0x04:  # 人体距离
                if data and len(data) >= 2:
                    self.human_distance = (data[0] << 8) | data[1]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Distance] {self.human_distance} cm")

            elif command == 0x05:  # 人体方位
                if data and len(data) == 6:
                    x, y, z = self._parse_human_position_data(data)
                    self.human_position_x = x
                    self.human_position_y = y
                    self.human_position_z = z
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Position] X={x}, Y={y}, Z={z}")

        # 呼吸监测 (0x81)
        elif control == 0x81:
            if command == 0x01:  # 呼吸状态
                if data and len(data) > 0:
                    self.breath_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["Normal", "High", "Low", "None"][
                            self.breath_status - 1] if 1 <= self.breath_status <= 4 else "Unknown"
                        print(f"[Breath] Status: {status_text}")

            elif command == 0x02:  # 呼吸数值
                if data and len(data) > 0:
                    self.breath_value = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Breath] Value: {self.breath_value}")

            elif command == 0x05:  # 呼吸波形
                if data and len(data) == 5:
                    waveform = self._parse_breath_waveform_data(data)
                    self.breath_waveform = list(waveform)
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Breath] Waveform updated: {waveform}")

        # 心率监测 (0x85)
        elif control == 0x85:
            if command == 0x02:  # 心率数值
                if data and len(data) > 0:
                    self.heart_rate_value = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Heart Rate] Value: {self.heart_rate_value}")

            elif command == 0x05:  # 心率波形
                if data and len(data) == 5:
                    waveform = self._parse_heart_rate_waveform_data(data)
                    self.heart_rate_waveform = list(waveform)
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Heart Rate] Waveform updated: {waveform}")

        # 睡眠监测 (0x84)
        elif control == 0x84:
            if command == 0x01:  # 入床/离床状态
                if data and len(data) > 0:
                    self.bed_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["Leave bed", "Enter bed", "None"][
                            self.bed_status] if self.bed_status < 3 else "Unknown"
                        print(f"[Bed] Status: {status_text}")

            elif command == 0x02:  # 睡眠状态
                if data and len(data) > 0:
                    self.sleep_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["Deep sleep", "Light sleep", "Awake", "None"][
                            self.sleep_status] if self.sleep_status < 4 else "Unknown"
                        print(f"[Sleep] Status: {status_text}")

            elif command == 0x03:  # 清醒时长
                if data and len(data) >= 2:
                    self.awake_duration = (data[0] << 8) | data[1]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Sleep] Awake duration: {self.awake_duration} min")

            elif command == 0x04:  # 浅睡时长
                if data and len(data) >= 2:
                    self.light_sleep_duration = (data[0] << 8) | data[1]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Sleep] Light sleep duration: {self.light_sleep_duration} min")

            elif command == 0x05:  # 深睡时长
                if data and len(data) >= 2:
                    self.deep_sleep_duration = (data[0] << 8) | data[1]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Sleep] Deep sleep duration: {self.deep_sleep_duration} min")

            elif command == 0x06:  # 睡眠质量评分
                if data and len(data) > 0:
                    self.sleep_quality_score = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Sleep] Quality score: {self.sleep_quality_score}")

            elif command == 0x0C:  # 睡眠综合状态
                if data and len(data) == 8:
                    comprehensive_data = self._parse_sleep_comprehensive_data(data)
                    # 更新到字典属性
                    self.sleep_comprehensive_status = {
                        'presence': comprehensive_data[0],
                        'sleep_status': comprehensive_data[1],
                        'avg_breath': comprehensive_data[2],
                        'avg_heart_rate': comprehensive_data[3],
                        'turnover_count': comprehensive_data[4],
                        'large_movement_ratio': comprehensive_data[5],
                        'small_movement_ratio': comprehensive_data[6],
                        'apnea_count': comprehensive_data[7]
                    }
                    if R60ABD1.DEBUG_ENABLED:
                        print(f"[Sleep] Comprehensive status updated")

            elif command == 0x0D:  # 睡眠质量分析/统计信息
                if data and len(data) == 12:
                    stats_data = self._parse_sleep_statistics_data(data)
                    # 更新对应的睡眠统计属性
                    self.sleep_quality_score = stats_data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        # 注意：stats_data[1]是总睡眠时长，需要根据实际情况决定如何分配
                        print(f"[Sleep] Statistics updated")

            elif command == 0x0E:  # 睡眠异常
                if data and len(data) > 0:
                    self.sleep_anomaly = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["Short sleep (<4h)", "Long sleep (>12h)", "No person anomaly", "Normal"][
                            self.sleep_anomaly] if self.sleep_anomaly < 4 else "Unknown"
                        print(f"[Sleep] Anomaly: {status_text}")

            elif command == 0x10:  # 睡眠质量评级
                if data and len(data) > 0:
                    self.sleep_quality_rating = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["None", "Good", "Normal", "Poor"][
                            self.sleep_quality_rating] if self.sleep_quality_rating < 4 else "Unknown"
                        print(f"[Sleep] Quality rating: {status_text}")

            elif command == 0x11:  # 异常挣扎状态
                if data and len(data) > 0:
                    self.abnormal_struggle_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["None", "Normal", "Abnormal"][
                            self.abnormal_struggle_status] if self.abnormal_struggle_status < 3 else "Unknown"
                        print(f"[Sleep] Struggle status: {status_text}")

            elif command == 0x12:  # 无人计时状态
                if data and len(data) > 0:
                    self.no_person_timing_status = data[0]
                    if R60ABD1.DEBUG_ENABLED:
                        status_text = ["None", "Normal", "Abnormal"][
                            self.no_person_timing_status] if self.no_person_timing_status < 3 else "Unknown"
                        print(f"[Sleep] No person timing: {status_text}")

    def close(self):
        """
        停止定时器，解析剩余数据帧，输出统计信息
        """
        # 停止定时器
        self._is_running = False
        self.timer.deinit()

        # 是否有查询在进行中
        self._query_in_progress = False
        # 是否收到查询响应
        self._query_response_received = False
        # 查询结果
        self._query_result = None
        # 当前查询类型
        self._current_query_type = None

        # 解析剩余数据帧
        try:
            frames = self.data_processor.read_and_parse()
            for frame in frames:
                self.update_properties_from_frame(frame)
        except Exception as e:
            raise Exception(f"Failed to deinitialize timer: {str(e)}")

        # 获取并输出统计信息
        try:
            stats = self.data_processor.get_stats()
            if R60ABD1.DEBUG_ENABLED:
                print("  [R60ABD1] Final statistics: %s" % format_time())
                print("  Total bytes received: %d" % stats['total_bytes_received'])
                print("  Total frames parsed: %d" % stats['total_frames_parsed'])
                print("  CRC errors: %d" % stats['crc_errors'])
                print("  Frame errors: %d" % stats['frame_errors'])
                print("  Invalid frames: %d" % stats['invalid_frames'])
        except Exception as e:
            raise Exception(f"Failed to get statistics: {str(e)}")

        # 清空缓冲区
        try:
            self.data_processor.clear_buffer()
        except Exception as e:
            raise Exception(f"Failed to clear buffer: {str(e)}")

        if R60ABD1.DEBUG_ENABLED:
            print("%s [R60ABD1] Resources fully released" % format_time())

# Python env   :
# -*- coding: utf-8 -*-
# @Time    : 2025/11/4 下午5:33
# @Author  : 李清水
# @File    : main.py
# @Description :

from machine import UART, Pin, Timer
import time
from data_flow_processor import DataFlowProcessor
from r60abd1 import R60ABD1, format_time

time.sleep(3)

# 初始化UART0：TX=16, RX=17，波特率115200
uart = UART(0, baudrate=115200, tx=Pin(16), rx=Pin(17), timeout=0)

# 创建DataFlowProcessor实例
processor = DataFlowProcessor(uart)

# 创建R60ABD1实例
device = R60ABD1(processor, parse_interval=50)

# ======================================== 功能函数 ============================================

def print_sensor_data():
    """打印传感器数据到Thonny控制台"""
    print("=" * 50)
    print("%s Sensor Data" % format_time())
    print("=" * 50)

    # 心率数据
    print("Heart Rate: %d bpm" % device.heart_rate_value)
    print("Heart Rate Waveform: %s" % str(device.heart_rate_waveform))

    # 呼吸数据
    print("Breath Rate: %d bpm" % device.breath_value)
    print("Breath Status: %d" % device.breath_status)
    print("Breath Waveform: %s" % str(device.breath_waveform))

    # 人体存在数据
    print("Movement Parameter: %d" % device.movement_parameter)
    print("Presence Status: %s" % ("Someone" if device.presence_status == 1 else "No one"))
    print("Motion Status: %s" % ["No motion", "Static", "Active"][
        device.motion_status] if device.motion_status < 3 else "Unknown")

    # 距离和位置
    print("Human Distance: %d cm" % device.human_distance)
    print("Human Position: X=%d, Y=%d, Z=%d" % (
    device.human_position_x, device.human_position_y, device.human_position_z))

    # 雷达状态
    print("Radar in Range: %s" % ("Yes" if device.radar_in_range else "No"))

    print("=" * 50)

# ======================================== 主程序 ============================================

# 上次打印时间
last_print_time = time.ticks_ms()
print_interval = 2000  # 2秒打印一次

success, product_model = device.query_product_model()
if success:
    print("Product Model: %s" % product_model)
else:
    print("Query Product Model failed")

success, product_id = device.query_product_id()
if success:
    print("Product ID: %s" % product_id)
else:
    print("Query Product ID failed")

success, hardware_model = device.query_hardware_model()
if success:
    print("Hardware Model: %s" % hardware_model)
else:
    print("Query Hardware Model failed")

success, firmware_version = device.query_firmware_version()
if success:
    print("Hardware Version: %s" % firmware_version)
else:
    print("Query Hardware Version failed")

success, init_status = device.query_init_complete()
if success:
    print("Init Status: %s" % init_status)
else:
    print("Query Init Status failed")

success, boundary_status = device.query_radar_range_boundary()
if success:
    status_text = "out of range" if boundary_status else "in range"
    print("Boundary Status: %s" % status_text)
else:
    print("Query Boundary Status failed")

try:
    while True:
        current_time = time.ticks_ms()

        # 定期打印传感器数据
        if time.ticks_diff(current_time, last_print_time) >= print_interval:
            # print_sensor_data()
            success, presence_status = device.query_presence_status()
            if success:
                print("Presence Status: %s" % ("Someone" if presence_status == 1 else "No one"))
            else:
                print("Query Presence Status failed")
            last_print_time = current_time

            success, heartbeat_status = device.query_heartbeat()
            if success:
                print("Heartbeat Status: %s" % ("Normal" if heartbeat_status == 1 else "Abnormal"))
            else:
                print("Query Heartbeat failed")

        # 小延迟，避免占用太多CPU
        time.sleep_ms(10)

except KeyboardInterrupt:
    print("%s Program interrupted by user" % format_time())

finally:
    # 清理资源
    print("%s Cleaning up resources..." % format_time())
    # 停止实例运行
    device.close()
    # 销毁实例
    del device
    print("%s Program exited" % format_time())

3.3.7 Reconstruction of the Business-Driven Layer: Frame Encapsulation, Instruction Decoupling and Response Unification

3.3.7.1 Unified Encapsulation of Frame Transmission

def build_and_send_frame(self, control_byte, command_byte, data=b''):
    # 帧头（协议固定为0x53 0x59）
    header = self.HEADER  # 类常量，如b'\x53\x59'
    # 控制字、命令字转换为单字节
    control = bytes([control_byte])
    command = bytes([command_byte])
    # 数据长度（按协议要求采用大端格式，2字节）
    data_len = len(data)
    length_bytes = bytes([(data_len >> 8) & 0xFF, data_len & 0xFF])  # 高位在前，低位在后
    # 组装帧主体（帧头+控制字+命令字+长度+数据）
    frame_without_crc = header + control + command + length_bytes + data
    # 计算CRC校验（协议规定为帧主体所有字节之和的低8位）
    crc = self._calculate_crc(frame_without_crc)  # 内部调用sum(frame_without_crc) & 0xFF
    # 帧尾（协议固定为0x54 0x43）
    trailer = self.TRAILER  # 类常量，如b'\x54\x43'
    # 完整帧拼接并发送
    complete_frame = frame_without_crc + bytes([crc]) + trailer
    self.uart.write(complete_frame)  # 通过串口发送
    return complete_frame  # 返回完整帧用于调试

3.3.7.2 Instruction Mapping Table: COMMAND_MAP Decoupled Design

# 指令类型常量（直观描述操作含义）
TYPE_QUERY_HEARTBEAT = 0  # 心跳包查询
TYPE_QUERY_PRODUCT_MODEL = 2  # 产品型号查询
TYPE_CONTROL_HEART_RATE_MONITOR_ON = 16  # 打开心率监测

# 指令映射表（关联常量与协议参数）
COMMAND_MAP = {
    TYPE_QUERY_HEARTBEAT: {
        'control_byte': 0x01,  # 控制字（系统指令）
        'command_byte': 0x80,  # 命令字（心跳查询）
        'data': bytes([0x0F])  # 默认数据（协议固定）
    },
    TYPE_QUERY_PRODUCT_MODEL: {
        'control_byte': 0x02,  # 控制字（产品信息）
        'command_byte': 0xA1,  # 命令字（型号查询）
        'data': bytes([0x0F])  # 默认数据
    },
    TYPE_CONTROL_HEART_RATE_MONITOR_ON: {
        'control_byte': 0x85,  # 控制字（心率监测）
        'command_byte': 0x00,  # 命令字（功能开关）
        'data': bytes([0x01])  # 数据（1表示打开）
    },
    # ... 其他指令映射 ...
}

3.3.7.3 Unification of Query Response Logic:_handle_query_response method

def _handle_query_response(self, expected_type, response_data, response_name):
    # 场景1：响应与当前查询类型匹配（正常流程）
    if (self._query_in_progress and  # 存在正在进行的查询
        self._current_query_type == expected_type and  # 响应类型匹配
        not self._query_response_received):  # 尚未收到响应
        self._query_result = response_data  # 记录结果
        self._query_response_received = True  # 标记响应已收到
        if R60ABD1.DEBUG_ENABLED:
            query_name = self.QUERY_NAME_MAP.get(expected_type, f"Unknown({expected_type})")
            print(f"[Query] {query_name} response received: {response_data}")
    
    # 场景2：响应与当前查询类型不匹配（并发冲突）
    elif self._query_in_progress and self._current_query_type != expected_type:
        if R60ABD1.DEBUG_ENABLED:
            current_query = self.QUERY_NAME_MAP.get(self._current_query_type, f"Unknown({self._current_query_type})")
            print(f"[Query] Unexpected {response_name} response during {current_query} query: {response_data}")
    
    # 场景3：无查询时收到响应（设备主动上报）
    elif not self._query_in_progress:
        if R60ABD1.DEBUG_ENABLED:
            print(f"[Query] Unsolicited {response_name} response: {response_data}")

# 产品型号查询响应处理（重构后）
if control == 0x02 and command == 0xA1 and data:
    product_model = self._parse_product_info_data(data)[0]
    self.product_model = product_model  # 更新属性
    self._handle_query_response(
        expected_type=TYPE_QUERY_PRODUCT_MODEL,
        response_data=product_model,
        response_name="Product Model"
    )

3.3.7.4 Test Verification After Refactoring

3.3.7.5 The attribute update of the business-driven layer strictly follows the principle of "single source of truth + response-driven"

def enable_human_presence(self, timeout=200):
    success, result = self._execute_operation(R60ABD1.TYPE_CONTROL_HUMAN_PRESENCE_ON, timeout=timeout)
    if success:  # 仅判断指令发送成功，未等设备响应确认
        self.presence_enabled = True  # 预判修改属性，存在风险
    return success, result

def enable_human_presence(self, timeout=200):
    # 仅发送“打开人体存在”指令，不修改任何属性
    return self._execute_operation(R60ABD1.TYPE_CONTROL_HUMAN_PRESENCE_ON, timeout=timeout)

def disable_human_presence(self, timeout=200):
    # 仅发送“关闭人体存在”指令，不预判执行结果
    return self._execute_operation(R60ABD1.TYPE_CONTROL_HUMAN_PRESENCE_OFF, timeout=timeout)

# 人体存在开关控制响应解析（唯一属性修改点）
if control == 0x80 and command == 0x00 and data:
    switch_status = (data[0] == 0x01)  # 以设备响应数据为唯一依据
    self.presence_enabled = switch_status  # 仅在此处修改属性
    # 匹配响应与操作类型，更新查询结果
    if data[0] == 0x01:
        self._handle_query_response(R60ABD1.TYPE_CONTROL_HUMAN_PRESENCE_ON, True, "Human Presence ON")
    else:
        self._handle_query_response(R60ABD1.TYPE_CONTROL_HUMAN_PRESENCE_OFF, True, "Human Presence OFF")

def query_human_distance(self, timeout=200):
    # 仅发送“人体距离查询”指令，不处理属性更新
    return self._execute_operation(R60ABD1.TYPE_QUERY_HUMAN_DISTANCE, timeout=timeout)

# 人体距离查询响应解析（唯一属性修改点）
if control == 0x80 and command == 0x84 and data and len(data) >= 2:
    distance = (data[0] << 8) | data[1]  # 解析设备响应的真实距离数据
    self.human_distance = distance  # 仅在此处修改属性
    self._handle_query_response(
        R60ABD1.TYPE_QUERY_HUMAN_DISTANCE,
        distance,
        "Human Distance"
    )

4. Integration, Optimization and Related Testing of Driver Code

4.1 Optimized Design of Initialization Method: Configuration, Fault Tolerance and Traceability

4.1.1 Core Optimization Points and Design Principles

# 全功能开启，高实时性配置
device = R60ABD1(
    processor,
    parse_interval=50,  # 高实时性，50ms解析一次
    presence_enabled=True,
    heart_rate_enabled=True,
    heart_rate_waveform_enabled=True,  # 开启心率波形上报
    breath_monitoring_enabled=True,
    breath_waveform_enabled=True,      # 开启呼吸波形上报
    sleep_monitoring_enabled=True,
    abnormal_struggle_enabled=True,    # 开启异常挣扎监测
    struggle_sensitivity=1,            # 中等灵敏度
    no_person_timing_enabled=True,     # 开启无人计时
    no_person_timing_duration=60,      # 无人计时60分钟
    sleep_cutoff_duration=120,         # 睡眠截止时长120分钟
    max_retries=3,                     # 最大重试3次
    retry_delay=200,                   # 重试延迟200ms
    init_timeout=10000                 # 初始化超时10秒
)

# 低功耗配置，关闭非必要功能
device = R60ABD1(
    processor,
    parse_interval=200,  # 低频率解析，降低功耗
    presence_enabled=True,
    heart_rate_enabled=True,
    heart_rate_waveform_enabled=False,  # 关闭心率波形（减少数据传输）
    breath_monitoring_enabled=True,
    breath_waveform_enabled=False,      # 关闭呼吸波形
    sleep_monitoring_enabled=True,
    abnormal_struggle_enabled=False,    # 关闭异常挣扎监测
    no_person_timing_enabled=False,     # 关闭无人计时
    max_retries=2,
    retry_delay=100,
    init_timeout=5000
)

# 错误示例：挣扎灵敏度传入3（仅支持0/1/2）
try:
    device = R60ABD1(processor, struggle_sensitivity=3)
except ValueError as e:
    print(e)  # 输出：struggle_sensitivity must be 0 (low), 1 (medium), or 2 (high)

# 自定义异常类
class DeviceInitializationError(Exception):
    """设备初始化错误异常"""
    pass

# 应用代码示例
try:
    device = R60ABD1(processor, parse_interval=300)
    # 获取初始化状态与错误信息
    init_status = device.get_configuration_status()
    if init_status['initialization_complete']:
        print("初始化成功！")
        print(f"设备型号：{init_status['device_info']['product_model']}")
    else:
        print(f"初始化部分失败，错误项：{init_status['configuration_errors']}")
except DeviceInitializationError as e:
    print(f"初始化失败：{e}")  
    # 输出：Device initialization failed: Failed to load Product Model

def _complete_initialization(self):
    start_time = time.ticks_ms()
    # 步骤1：读取设备信息（产品型号、ID等）
    self._load_device_information()
    # 步骤2：等待设备初始化，未完成则复位
    if not self._wait_for_device_initialization():
        self._reset_and_wait_for_initialization()
    # 步骤3：自动配置功能（基于__init__参数）
    self._auto_configure_device()
    # 步骤4：验证关键配置（如功能开关状态）
    self._verify_critical_configuration()
    print(f"初始化耗时：{time.ticks_diff(time.ticks_ms(), start_time)}ms")

4.1.2 Analysis of Key Function Codes

4.1.2.1 Device Reset and Initialization Waiting

def _reset_and_wait_for_initialization(self):
    # 发送复位指令（带重试）
    reset_success = self._execute_with_retry(self.reset_module, "Reset Device", timeout=1000)
    if not reset_success:
        return False
    time.sleep(3)  # 等待设备重启
    return self._wait_for_device_initialization(timeout=10000)

# 调用示例：在初始化中自动触发
if not self._wait_for_device_initialization():
    print("设备未初始化，尝试复位...")
    reset_success = self._reset_and_wait_for_initialization()
    print(f"复位后初始化：{'成功' if reset_success else '失败'}")

4.1.2.2 Configuration Error Traceability

# 调用示例：初始化后查询状态
init_status = device.get_configuration_status()
print(f"初始化完成：{init_status['initialization_complete']}")
print(f"错误列表：{init_status['configuration_errors']}")
# 输出示例：
# 初始化完成：True
# 错误列表：["Failed to load Hardware Model", "Enable Abnormal Struggle Monitor failed"]

4.1.2.3 Execution of Operations with Retry

def _execute_with_retry(self, operation, operation_name, timeout=200):
    for attempt in range(self.max_retries + 1):
        try:
            success, result = operation(timeout=timeout)
            if success:
                return True
            if attempt < self.max_retries:
                time.sleep_ms(self.retry_delay)
        except Exception as e:
            if attempt < self.max_retries:
                time.sleep_ms(self.retry_delay)
            else:
                print(f"{operation_name}重试{self.max_retries+1}次失败：{e}")
    return False

# 调用示例：读取产品型号（失败自动重试3次）
success = self._execute_with_retry(self.query_product_model, "Load Product Model")

4.1.2 Complete Code Example for the Initialization Section

# 自定义异常类
class DeviceInitializationError(Exception):
    """设备初始化错误异常"""
    pass

def __init__(self, data_processor, parse_interval=200,
             presence_enabled=True,
             heart_rate_enabled=True, heart_rate_waveform_enabled=False,
             breath_monitoring_enabled=True, breath_waveform_enabled=False,
             sleep_monitoring_enabled=True,
             abnormal_struggle_enabled=False, struggle_sensitivity=1,
             no_person_timing_enabled=False, no_person_timing_duration=30,
             sleep_cutoff_duration=120,
             max_retries=3, retry_delay=100, init_timeout=5000):
    """
    初始化R60ABD1实例

    Args:
        data_processor: DataFlowProcessor实例
        parse_interval: 数据解析间隔，单位毫秒 (建议50-200ms)
        presence_enabled: 是否开启人体存在信息监测
        heart_rate_enabled: 是否开启心率监测
        heart_rate_waveform_enabled: 是否开启心率波形主动上报
        breath_monitoring_enabled: 是否开启呼吸监测
        breath_waveform_enabled: 是否开启呼吸波形主动上报
        sleep_monitoring_enabled: 是否开启睡眠监测
        abnormal_struggle_enabled: 是否开启异常挣扎监测
        struggle_sensitivity: 挣扎灵敏度 (0=低, 1=中, 2=高)
        no_person_timing_enabled: 是否开启无人计时功能
        no_person_timing_duration: 无人计时时长 (30-180分钟)
        sleep_cutoff_duration: 睡眠截止时长 (5-120分钟)
        max_retries: 最大重试次数
        retry_delay: 重试延迟时间，单位毫秒
        init_timeout: 初始化超时时间，单位毫秒

    Raises:
        ValueError: 参数验证失败
        DeviceInitializationError: 设备初始化失败
    """
    # 参数验证
    self._validate_init_parameters(
        parse_interval, struggle_sensitivity, no_person_timing_duration,
        sleep_cutoff_duration, max_retries, retry_delay, init_timeout
    )

    if parse_interval > 500:
        raise ValueError("parse_interval must be less than 500ms")

    self.data_processor = data_processor
    self.parse_interval = parse_interval
    self.max_retries = max_retries
    self.retry_delay = retry_delay
    self.init_timeout = init_timeout

    # 添加运行状态标志
    self._is_running = False
    self._initialization_complete = False
    self._configuration_errors = []

    # ============================= 系统级属性 ============================

    # 心跳包监控
    # 最后接收心跳包时间戳(ms)
    self.heartbeat_last_received = 0
    # 心跳超时累计次数
    self.heartbeat_timeout_count = 0
    # 实际心跳间隔统计(ms)
    self.heartbeat_interval = 0

    # 系统状态
    # 初始化完成状态(True/False)
    self.system_initialized = False
    # 初始化完成时间戳(ms)
    self.system_initialized_timestamp = 0
    # 模组复位状态标记
    self.module_reset_flag = False
    # 模组复位时间戳(ms)
    self.module_reset_timestamp = 0

    # 产品信息
    # 产品型号(字符串)
    self.product_model = ""
    # 产品ID(字符串)
    self.product_id = ""
    # 硬件型号(字符串)
    self.hardware_model = ""
    # 固件版本(字符串)
    self.firmware_version = ""

    # ============================ 雷达探测属性 ============================

    # 位置状态
    # 是否在探测范围内
    self.radar_in_range = False

    # =========================== 人体存在检测属性 ==========================

    # 基本状态
    # 人体存在功能开关
    self.presence_enabled = presence_enabled
    # 存在状态
    # 0:无人, 1:有人
    self.presence_status = 0
    # 运动状态
    # 0:无, 1:静止, 2:活跃
    self.motion_status = 0

    # 量化数据
    # 体动参数(0-100)
    self.movement_parameter = 0
    # 人体距离(0-65535 cm)
    self.human_distance = 0
    # X坐标(有符号)
    self.human_position_x = 0
    # Y坐标(有符号)
    self.human_position_y = 0
    # Z坐标(有符号)
    self.human_position_z = 0

    # ============================= 呼吸监测属性 ===========================

    # 功能配置
    # 呼吸监测开关
    self.breath_monitoring_enabled = breath_monitoring_enabled
    # 呼吸波形上报开关
    self.breath_waveform_enabled = False
    # 低缓呼吸阈值(10-20次/min)
    self.low_breath_threshold = 10

    # 监测数据
    # 1:正常, 2:过高, 3:过低, 4:无
    self.breath_status = 0
    # 呼吸数值(0-35次/分)
    self.breath_value = 0
    # 5个字节的波形数据
    self.breath_waveform = [0, 0, 0, 0, 0]

    # ============================= 心率监测属性 ============================

    # 功能配置
    # 心率监测开关
    self.heart_rate_enabled = heart_rate_enabled
    # 心率波形上报开关
    self.heart_rate_waveform_enabled = False

    # 监测数据
    # 心率数值(60-120)
    self.heart_rate_value = 0
    # 5个字节的波形数据
    self.heart_rate_waveform = [0, 0, 0, 0, 0]

    # ============================ 睡眠监测属性 ============================

    # 基础状态
    # 睡眠监测开关
    self.sleep_monitoring_enabled = sleep_monitoring_enabled

    # 入床/离床状态
    # 0:离床, 1:入床, 2:无
    self.bed_status = 0
    # 睡眠状态
    # 0:深睡, 1:浅睡, 2:清醒, 3:无
    self.sleep_status = 0

    # 时长统计
    # 清醒时长(分钟)
    self.awake_duration = 0
    # 浅睡时长(分钟)
    self.light_sleep_duration = 0
    # 深睡时长(分钟)
    self.deep_sleep_duration = 0

    # 睡眠质量
    # 睡眠质量评分(0-100)
    self.sleep_quality_score = 0
    # 睡眠质量评级
    self.sleep_quality_rating = 0

    # 综合状态
    # 包含8个字段的字典
    self.sleep_comprehensive_status = {}
    # 睡眠异常状态
    self.sleep_anomaly = 0
    # 异常挣扎状态
    self.abnormal_struggle_status = 0
    # 无人计时状态
    self.no_person_timing_status = 0

    # 配置参数
    # 异常挣扎开关
    self.abnormal_struggle_enabled = abnormal_struggle_enabled
    # 无人计时开关
    self.no_person_timing_enabled = no_person_timing_enabled
    # 无人计时时长
    self.no_person_timing_duration = no_person_timing_duration
    # 睡眠截止时长
    self.sleep_cutoff_duration = sleep_cutoff_duration
    # 挣扎灵敏度
    self.struggle_sensitivity = struggle_sensitivity

    # 查询状态管理
    # 是否有查询在进行中
    self._query_in_progress = False
    # 是否收到查询响应
    self._query_response_received = False
    # 查询结果
    self._query_result = None
    # 当前查询类型
    self._current_query_type = None
    # 默认查询超时时间(ms)
    self._query_timeout = 200

    # 内部使用的定时器
    self._timer = Timer(-1)

    try:
        # 启动定时器
        self._start_timer()

        # 执行完整的初始化流程
        self._complete_initialization()

        self._initialization_complete = True

        if R60ABD1.DEBUG_ENABLED:
            print(f"[Init] R60ABD1 initialized successfully")
            status = self.get_configuration_status()
            print(f"[Init] Configuration errors: {len(status['configuration_errors'])}")
            print(f"[Init] Product: {self.product_model} v{self.firmware_version}")

    except Exception as e:
        # 初始化失败，停止定时器
        self._is_running = False
        if hasattr(self, '_timer'):
            self._timer.deinit()
        raise DeviceInitializationError(f"Device initialization failed: {str(e)}")

def _validate_init_parameters(self, parse_interval, struggle_sensitivity,
                              no_person_timing_duration, sleep_cutoff_duration,
                              max_retries, retry_delay, init_timeout):
    """验证初始化参数"""
    if parse_interval > 500 or parse_interval < 10:
        raise ValueError("parse_interval must be between 10ms and 500ms")

    if struggle_sensitivity not in [self.SENSITIVITY_LOW, self.SENSITIVITY_MEDIUM, self.SENSITIVITY_HIGH]:
        raise ValueError("struggle_sensitivity must be 0 (low), 1 (medium), or 2 (high)")

    if no_person_timing_duration < 30 or no_person_timing_duration > 180 or no_person_timing_duration % 10 != 0:
        raise ValueError("no_person_timing_duration must be between 30-180 minutes in steps of 10")

    if sleep_cutoff_duration < 5 or sleep_cutoff_duration > 120:
        raise ValueError("sleep_cutoff_duration must be between 5-120 minutes")

    if max_retries < 0 or max_retries > 10:
        raise ValueError("max_retries must be between 0 and 10")

    if retry_delay < 0 or retry_delay > 1000:
        raise ValueError("retry_delay must be between 0ms and 1000ms")

    if init_timeout < 1000 or init_timeout > 30000:
        raise ValueError("init_timeout must be between 1000ms and 30000ms")

def _complete_initialization(self):
    """
    完整的初始化流程

    Raises:
        DeviceInitializationError: 初始化失败
    """
    start_time = time.ticks_ms()

    # 步骤1: 读取设备基本信息
    device_info_loaded = self._load_device_information()
    if not device_info_loaded:
        raise DeviceInitializationError("Failed to load device information")

    # 步骤2: 检查并等待设备初始化完成
    init_success = self._wait_for_device_initialization()
    if not init_success:
        # 尝试重启设备
        if R60ABD1.DEBUG_ENABLED:
            print("[Init] Device not initialized, attempting reset...")
        reset_success = self._reset_and_wait_for_initialization()
        if not reset_success:
            raise DeviceInitializationError("Device initialization failed even after reset")

    # 步骤3: 配置设备功能
    self._auto_configure_device()

    # 步骤4: 验证关键功能配置
    self._verify_critical_configuration()

    elapsed_time = time.ticks_diff(time.ticks_ms(), start_time)
    if R60ABD1.DEBUG_ENABLED:
        print(f"[Init] Initialization completed in {elapsed_time}ms")

def _load_device_information(self):
    """
    加载设备基本信息

    Returns:
        bool: 是否成功加载所有设备信息
    """
    info_queries = [
        ("Product Model", self.query_product_model),
        ("Product ID", self.query_product_id),
        ("Hardware Model", self.query_hardware_model),
        ("Firmware Version", self.query_firmware_version)
    ]

    all_success = True
    for info_name, query_func in info_queries:
        success = self._execute_with_retry(query_func, f"Load {info_name}")
        if not success:
            all_success = False
            self._configuration_errors.append(f"Failed to load {info_name}")
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Init] Warning: Failed to load {info_name}")

    return all_success

def _wait_for_device_initialization(self, timeout=None):
    """
    等待设备初始化完成

    Args:
        timeout: 超时时间，单位毫秒

    Returns:
        bool: 设备是否初始化完成
    """
    if timeout is None:
        timeout = self.init_timeout

    start_time = time.ticks_ms()

    while time.ticks_diff(time.ticks_ms(), start_time) < timeout:
        success, init_status = self.query_init_complete(timeout=500)
        if success and init_status:
            if R60ABD1.DEBUG_ENABLED:
                print("[Init] Device initialization confirmed")
            return True

        # 短暂延迟后重试
        time.sleep_ms(200)

    if R60ABD1.DEBUG_ENABLED:
        print("[Init] Device initialization timeout")
    return False

def _reset_and_wait_for_initialization(self):
    """
    重置设备并等待初始化完成

    Returns:
        bool: 重置和初始化是否成功
    """
    # 发送复位指令
    reset_success = self._execute_with_retry(
        self.reset_module,
        "Reset Device",
        timeout=1000
    )

    if not reset_success:
        return False

    # 等待3秒让设备重启
    if R60ABD1.DEBUG_ENABLED:
        print("[Init] Waiting 3 seconds for device reset...")
    time.sleep(3)

    # 重新等待初始化完成
    return self._wait_for_device_initialization(timeout=10000)  # 10秒超时

def _auto_configure_device(self):
    """
    自动配置设备功能
    """
    configuration_steps = []

    # 基础功能配置
    if self.presence_enabled:
        configuration_steps.append(("Enable Human Presence", self.enable_human_presence))
    else:
        configuration_steps.append(("Disable Human Presence", self.disable_human_presence))

    # 心率监测配置
    if self.heart_rate_enabled:
        configuration_steps.append(("Enable Heart Rate Monitor", self.enable_heart_rate_monitor))
        if self.heart_rate_waveform_enabled:
            configuration_steps.append(
                ("Enable Heart Rate Waveform Report", self.enable_heart_rate_waveform_report))
        else:
            configuration_steps.append(
                ("Disable Heart Rate Waveform Report", self.disable_heart_rate_waveform_report))
    else:
        configuration_steps.append(("Disable Heart Rate Monitor", self.disable_heart_rate_monitor))

    # 呼吸监测配置
    if self.breath_monitoring_enabled:
        configuration_steps.append(("Enable Breath Monitor", self.enable_breath_monitor))
        if self.breath_waveform_enabled:
            configuration_steps.append(("Enable Breath Waveform Report", self.enable_breath_waveform_report))
        else:
            configuration_steps.append(("Disable Breath Waveform Report", self.disable_breath_waveform_report))
    else:
        configuration_steps.append(("Disable Breath Monitor", self.disable_breath_monitor))

    # 睡眠监测配置
    if self.sleep_monitoring_enabled:
        configuration_steps.append(("Enable Sleep Monitor", self.enable_sleep_monitor))

        # 异常挣扎配置
        if self.abnormal_struggle_enabled:
            configuration_steps.append(("Enable Abnormal Struggle Monitor", self.enable_abnormal_struggle_monitor))
            # 设置挣扎灵敏度
            configuration_steps.append(("Set Struggle Sensitivity",
                                        lambda: self.set_struggle_sensitivity(self.struggle_sensitivity)))
        else:
            configuration_steps.append(
                ("Disable Abnormal Struggle Monitor", self.disable_abnormal_struggle_monitor))

        # 无人计时配置
        if self.no_person_timing_enabled:
            configuration_steps.append(("Enable No Person Timing", self.enable_no_person_timing))
            # 设置无人计时时长
            configuration_steps.append(("Set No Person Timing Duration",
                                        lambda: self.set_no_person_timing_duration(self.no_person_timing_duration)))
        else:
            configuration_steps.append(("Disable No Person Timing", self.disable_no_person_timing))

        # 设置睡眠截止时长
        configuration_steps.append(("Set Sleep End Duration",
                                    lambda: self.set_sleep_end_duration(self.sleep_cutoff_duration)))
    else:
        configuration_steps.append(("Disable Sleep Monitor", self.disable_sleep_monitor))

    # 执行配置步骤
    for step_name, step_function in configuration_steps:
        success = self._execute_with_retry(step_function, step_name)
        if not success:
            self._configuration_errors.append(f"Failed to {step_name}")
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Init] Warning: {step_name} failed")

def _verify_critical_configuration(self):
    """
    验证关键配置是否成功
    """
    critical_verifications = []

    # 验证设备初始化状态
    critical_verifications.append(("Device Initialization", self.query_init_complete))

    # 验证雷达范围状态
    critical_verifications.append(("Radar Range", self.query_radar_range_boundary))

    # 根据启用的功能添加验证
    if self.presence_enabled:
        critical_verifications.append(("Presence Detection", self.query_human_presence_switch))

    if self.heart_rate_enabled:
        critical_verifications.append(("Heart Rate Monitor", self.query_heart_rate_monitor_switch))

    if self.breath_monitoring_enabled:
        critical_verifications.append(("Breath Monitor", self.query_breath_monitor_switch))

    if self.sleep_monitoring_enabled:
        critical_verifications.append(("Sleep Monitor", self.query_sleep_monitor_switch))

    # 执行验证
    for verify_name, verify_func in critical_verifications:
        success, result = verify_func(timeout=500)
        if not success:
            self._configuration_errors.append(f"Verification failed: {verify_name}")
            if R60ABD1.DEBUG_ENABLED:
                print(f"[Init] Warning: {verify_name} verification failed")

def _execute_with_retry(self, operation, operation_name, timeout=200):
    """
    带重试的执行操作
    """
    for attempt in range(self.max_retries + 1):
        try:
            success, result = operation(timeout=timeout)
            if success:
                return True

            if attempt < self.max_retries:
                time.sleep_ms(self.retry_delay)

        except Exception as e:
            if attempt < self.max_retries:
                time.sleep_ms(self.retry_delay)
            else:
                if R60ABD1.DEBUG_ENABLED:
                    print(f"[Init] {operation_name} failed after {self.max_retries + 1} attempts: {e}")

    return False

def get_configuration_status(self):
    """
    获取设备配置状态
    """
    return {
        'initialization_complete': self._initialization_complete,
        'configuration_errors': self._configuration_errors.copy(),
        'device_info': {
            'product_model': self.product_model,
            'product_id': self.product_id,
            'hardware_model': self.hardware_model,
            'firmware_version': self.firmware_version
        },
        'current_settings': {
            'presence_enabled': self.presence_enabled,
            'heart_rate_enabled': self.heart_rate_enabled,
            'heart_rate_waveform_enabled': self.heart_rate_waveform_enabled,
            'breath_monitoring_enabled': self.breath_monitoring_enabled,
            'breath_waveform_enabled': self.breath_waveform_enabled,
            'sleep_monitoring_enabled': self.sleep_monitoring_enabled,
            'abnormal_struggle_enabled': self.abnormal_struggle_enabled,
            'struggle_sensitivity': self.struggle_sensitivity,
            'no_person_timing_enabled': self.no_person_timing_enabled,
            'no_person_timing_duration': self.no_person_timing_duration,
            'sleep_cutoff_duration': self.sleep_cutoff_duration
        }
    }

4.2 Test Script: Full Function Coverage and Rapid Verification

4.2.1 Core Dimensions and Implementation Approaches of Test-Driven Libraries

4.2.2.1 Device Reset and Initialization Waiting

# 初始化配置代码片段（来自main.py）
uart = UART(0, baudrate=115200, tx=Pin(16), rx=Pin(17), timeout=0)
processor = DataFlowProcessor(uart)
# 尝试创建驱动实例（触发参数校验与初始化流程）
try:
    device = R60ABD1(processor, parse_interval=200)
    print("驱动实例创建成功")
except ValueError as e:
    print(f"参数校验失败：{e}")  # 验证参数合法性（如parse_interval超限）
except DeviceInitializationError as e:
    print(f"初始化失败：{e}")  # 验证设备通信/配置异常处理

# 验证设备基础信息读取（初始化关键步骤）
success, product_model = device.query_product_model()
assert success, "产品型号查询失败，初始化异常"
print(f"产品型号：{product_model}")  # 验证设备信息读取正确

4.2.2.2 Functional Interface Test: Covers all types of interfaces including query, control and configuration

# 主动查询数据测试（来自main.py的print_active_query_data函数核心逻辑）
def test_query_interfaces():
    # 测试人体距离查询
    success, distance = device.query_human_distance(timeout=200)
    if success:
        assert isinstance(distance, int) and 0 <= distance <= 65535, "距离值范围异常"
        print(f"人体距离查询成功：{distance}cm")
    else:
        print("人体距离查询失败（可能设备未检测到目标）")
    
    # 测试心率查询
    success, heart_rate = device.query_heart_rate_value(timeout=200)
    if success:
        assert isinstance(heart_rate, int) and 0 <= heart_rate <= 200, "心率值范围异常"
        print(f"心率查询成功：{heart_rate}bpm")
    else:
        print("心率查询失败（可能未开启心率监测）")

test_query_interfaces()

def test_control_interfaces():
    # 测试开启人体存在监测
    success, _ = device.enable_human_presence()
    assert success, "开启人体存在监测失败"
    
    # 验证功能是否生效（通过查询接口确认）
    success, status = device.query_human_presence_switch()
    assert success and status is True, "人体存在监测未实际开启"
    print("人体存在监测开启成功并验证通过")
    
    # 测试关闭人体存在监测
    success, _ = device.disable_human_presence()
    assert success, "关闭人体存在监测失败"
    
    success, status = device.query_human_presence_switch()
    assert success and status is False, "人体存在监测未实际关闭"
    print("人体存在监测关闭成功并验证通过")

test_control_interfaces()

def test_config_interfaces():
    # 测试设置挣扎灵敏度为中等（1）
    target_sensitivity = 1
    success, _ = device.set_struggle_sensitivity(target_sensitivity)
    assert success, "设置挣扎灵敏度失败"
    
    # 验证配置是否生效
    success, sensitivity = device.query_struggle_sensitivity()
    assert success and sensitivity == target_sensitivity, "挣扎灵敏度配置未生效"
    print(f"挣扎灵敏度设置为{target_sensitivity}（中等）并验证通过")
    
    # 测试设置无人计时时长为60分钟
    target_duration = 60
    success, _ = device.set_no_person_timing_duration(target_duration)
    assert success, "设置无人计时时长失败"
    
    success, duration = device.query_no_person_timing_duration()
    assert success and duration == target_duration, "无人计时时长配置未生效"
    print(f"无人计时时长设置为{target_duration}分钟并验证通过")

test_config_interfaces()

4.2.2.3 Real-time Data Monitoring Test: Verify Active Reporting and Attribute Synchronization

# 实时上报数据监控（来自main.py的核心逻辑）
def test_realtime_data():
    last_print = time.ticks_ms()
    print_interval = 2000  # 每2秒打印一次实时属性
    try:
        while time.ticks_diff(time.ticks_ms(), last_print) < 10000:  # 监控10秒
            current = time.ticks_ms()
            if time.ticks_diff(current, last_print) >= print_interval:
                # 打印驱动类属性（验证主动上报数据是否同步）
                print(f"\n实时属性（{time.strftime('%H:%M:%S')}）：")
                print(f"存在状态：{'有人' if device.presence_status == 1 else '无人'}")
                print(f"呼吸频率：{device.breath_value}bpm")
                print(f"心率波形：{device.heart_rate_waveform}")
                last_print = current
            time.sleep_ms(10)
    except KeyboardInterrupt:
        pass

test_realtime_data()

4.2.2 Complete Code Example of Test Script

# Python env   : MicroPython v1.23.0
# -*- coding: utf-8 -*-
# @Time    : 2025/11/4 下午5:33
# @Author  : 李清水
# @File    : main.py
# @Description : 测试R60ABD1雷达设备驱动类的代码
# @License : CC BY-NC 4.0

# ======================================== 导入相关模块 =========================================

from machine import UART, Pin, Timer
import time
from data_flow_processor import DataFlowProcessor
from r60abd1 import R60ABD1, format_time

# ======================================== 全局变量 ============================================

# 上次打印时间
last_print_time = time.ticks_ms()
# 定时打印间隔：2秒打印一次
print_interval = 2000

# ======================================== 功能函数 ============================================

def print_report_sensor_data():
    """打印传感器数据到Thonny控制台"""

    # 声明全局变量
    global device

    print("=" * 50)
    print("%s Sensor Data" % format_time())
    print("=" * 50)

    # 心率数据
    print("Report Heart Rate: %d bpm" % device.heart_rate_value)
    print("Report Heart Rate Waveform: %s" % str(device.heart_rate_waveform))

    # 呼吸数据
    print("Report Breath Rate: %d bpm" % device.breath_value)
    print("Report Breath Status: %d" % device.breath_status)
    print("Report Breath Waveform: %s" % str(device.breath_waveform))

    # 人体存在数据
    print("Report Movement Parameter: %d" % device.movement_parameter)
    print("Report Presence Status: %s" % ("Someone" if device.presence_status == 1 else "No one"))
    print("Report Motion Status: %s" % ["No motion", "Static", "Active"][
        device.motion_status] if device.motion_status < 3 else "Unknown")

    # 距离和位置
    print("Report Human Distance: %d cm" % device.human_distance)
    print("Report Human Position: X=%d, Y=%d, Z=%d" % (
    device.human_position_x, device.human_position_y, device.human_position_z))

    # 雷达状态
    print("Report Radar in Range: %s" % ("Yes" if device.radar_in_range else "No"))

    print("=" * 50)

def print_active_query_data(timeout=200):
    """
    主动查询并打印传感器数据（阻塞式查询）
    """
    # 声明全局变量
    global device

    print("=" * 50)
    print("%s Active Query Sensor Data" % format_time())
    print("=" * 50)

    # 查询人体方位
    success, direction_data = device.query_human_direction(timeout)
    if success:
        x, y, z = direction_data
        print("Query Human Position: X=%d, Y=%d, Z=%d" % (x, y, z))
    else:
        print("Query Human Position: Failed")

    time.sleep(0.5)

    # 查询人体距离
    success, distance = device.query_human_distance(timeout)
    if success:
        print("Query Human Distance: %d cm" % distance)
    else:
        print("Query Human Distance: Failed")

    time.sleep(0.5)

    # 查询运动信息
    success, motion_status = device.query_human_motion_info(timeout)
    if success:
        motion_text = ["No motion", "Static", "Active"][motion_status] if motion_status < 3 else "Unknown"
        print("Query Motion Status: %s" % motion_text)
    else:
        print("Query Motion Status: Failed")

    time.sleep(0.5)

    # 查询体动参数
    success, motion_param = device.query_human_body_motion_param(timeout)
    if success:
        print("Query Movement Parameter: %d" % motion_param)
    else:
        print("Query Movement Parameter: Failed")

    time.sleep(0.5)

    # 查询存在状态
    success, presence_status = device.query_presence_status(timeout)
    if success:
        status_text = "Someone" if presence_status == 1 else "No one"
        print("Query Presence Status: %s" % status_text)
    else:
        print("Query Presence Status: Failed")

    time.sleep(0.5)

    # 查询心率数值
    success, heart_rate = device.query_heart_rate_value(timeout)
    if success:
        print("Query Heart Rate: %d bpm" % heart_rate)
    else:
        print("Query Heart Rate: Failed")

    time.sleep(0.5)

    # 查询心率波形
    success, heart_rate_waveform = device.query_heart_rate_waveform(timeout)
    if success:
        print("Query Heart Rate Waveform: %s" % str(heart_rate_waveform))
    else:
        print("Query Heart Rate Waveform: Failed")

    time.sleep(0.5)

    # 查询呼吸数值
    success, breath_rate = device.query_breath_value(timeout)
    if success:
        print("Query Breath Rate: %d bpm" % breath_rate)
    else:
        print("Query Breath Rate: Failed")

    time.sleep(0.5)

    # 查询呼吸波形
    success, breath_waveform = device.query_breath_waveform(timeout)
    if success:
        print("Query Breath Waveform: %s" % str(breath_waveform))
    else:
        print("Query Breath Waveform: Failed")

    time.sleep(0.5)

    # 查询呼吸信息
    success, breath_info = device.query_breath_info(timeout)
    if success:
        status_text = ["Normal", "High", "Low", "None"][breath_info - 1] if 1 <= breath_info <= 4 else "Unknown"
        print("Query Breath Info: %d - %s" % (breath_info, status_text))
    else:
        print("Query Breath Info: Failed")

    time.sleep(0.5)

    # 查询床状态
    success, bed_status = device.query_bed_status(timeout)
    if success:
        status_text = ["Leave bed", "Enter bed", "None"][bed_status] if bed_status < 3 else "Unknown"
        print("Query Bed Status: %d - %s" % (bed_status, status_text))
    else:
        print("Query Bed Status: Failed")

    time.sleep(0.5)

    # 查询无人计时状态
    success, no_person_timing_status = device.query_no_person_timing_status(timeout)
    if success:
        status_text = ["None", "Normal", "Abnormal"][
            no_person_timing_status] if no_person_timing_status < 3 else "Unknown"
        print("Query No Person Timing Status: %d - %s" % (no_person_timing_status, status_text))
    else:
        print("Query No Person Timing Status: Failed")

    time.sleep(0.5)

    # 查询睡眠状态
    success, sleep_status = device.query_sleep_status(timeout)
    if success:
        status_text = ["Deep sleep", "Light sleep", "Awake", "None"][sleep_status] if sleep_status < 4 else "Unknown"
        print("Query Sleep Status: %d - %s" % (sleep_status, status_text))
    else:
        print("Query Sleep Status: Failed")

    time.sleep(0.5)

    # 查询清醒时长
    success, awake_duration = device.query_awake_duration(timeout)
    if success:
        print("Query Awake Duration: %d min" % awake_duration)
    else:
        print("Query Awake Duration: Failed")

    time.sleep(0.5)

    # 查询浅睡时长
    success, light_sleep_duration = device.query_light_sleep_duration(timeout)
    if success:
        print("Query Light Sleep Duration: %d min" % light_sleep_duration)
    else:
        print("Query Light Sleep Duration: Failed")

    time.sleep(0.5)

    # 查询深睡时长
    success, deep_sleep_duration = device.query_deep_sleep_duration(timeout)
    if success:
        print("Query Deep Sleep Duration: %d min" % deep_sleep_duration)
    else:
        print("Query Deep Sleep Duration: Failed")

    time.sleep(0.5)

    # 查询睡眠质量评分
    success, sleep_quality_score = device.query_sleep_quality_score(timeout)
    if success:
        print("Query Sleep Quality Score: %d/100" % sleep_quality_score)
    else:
        print("Query Sleep Quality Score: Failed")

    time.sleep(0.5)

    # 查询睡眠综合状态
    success, sleep_comprehensive_status = device.query_sleep_comprehensive_status(timeout)
    if success:
        print("Query Sleep Comprehensive Status: Success")
        # 可以进一步解析和显示详细数据
        if len(sleep_comprehensive_status) >= 8:
            print("  - Presence: %s" % ("Someone" if sleep_comprehensive_status[0] == 1 else "No one"))
            print("  - Sleep Status: %s" % ["Deep sleep", "Light sleep", "Awake", "None"][sleep_comprehensive_status[1]] if sleep_comprehensive_status[1] < 4 else "Unknown")
            print("  - Avg Breath: %d bpm" % sleep_comprehensive_status[2])
            print("  - Avg Heart Rate: %d bpm" % sleep_comprehensive_status[3])
            print("  - Turnover Count: %d" % sleep_comprehensive_status[4])
            print("  - Large Movement Ratio: %d%%" % sleep_comprehensive_status[5])
            print("  - Small Movement Ratio: %d%%" % sleep_comprehensive_status[6])
            print("  - Apnea Count: %d" % sleep_comprehensive_status[7])
    else:
        print("Query Sleep Comprehensive Status: Failed")

    time.sleep(0.5)

    # 查询睡眠异常
    success, sleep_anomaly = device.query_sleep_anomaly(timeout)
    if success:
        status_text = ["Short sleep (<4h)", "Long sleep (>12h)", "No person anomaly", "Normal"][sleep_anomaly] if sleep_anomaly < 4 else "Unknown"
        print("Query Sleep Anomaly: %d - %s" % (sleep_anomaly, status_text))
    else:
        print("Query Sleep Anomaly: Failed")

    time.sleep(0.5)

    # 查询睡眠统计
    success, sleep_statistics = device.query_sleep_statistics(timeout)
    if success:
        print("Query Sleep Statistics: Success")
        # 可以进一步解析和显示详细数据
        if len(sleep_statistics) >= 11:
            print("  - Quality Score: %d/100" % sleep_statistics[0])
            print("  - Total Sleep Duration: %d min" % sleep_statistics[1])
            print("  - Awake Ratio: %d%%" % sleep_statistics[2])
            print("  - Light Sleep Ratio: %d%%" % sleep_statistics[3])
            print("  - Deep Sleep Ratio: %d%%" % sleep_statistics[4])
            print("  - Leave Bed Duration: %d min" % sleep_statistics[5])
            print("  - Leave Bed Count: %d" % sleep_statistics[6])
            print("  - Turnover Count: %d" % sleep_statistics[7])
            print("  - Avg Breath: %d bpm" % sleep_statistics[8])
            print("  - Avg Heart Rate: %d bpm" % sleep_statistics[9])
            print("  - Apnea Count: %d" % sleep_statistics[10])
    else:
        print("Query Sleep Statistics: Failed")

    time.sleep(0.5)

    # 查询睡眠质量评级
    success, sleep_quality_level = device.query_sleep_quality_level(timeout)
    if success:
        status_text = ["None", "Good", "Normal", "Poor"][sleep_quality_level] if sleep_quality_level < 4 else "Unknown"
        print("Query Sleep Quality Level: %d - %s" % (sleep_quality_level, status_text))
    else:
        print("Query Sleep Quality Level: Failed")

    print("=" * 50)

# ======================================== 自定义类 ============================================

# ======================================== 初始化配置 ==========================================

# 上电延时
time.sleep(3)
# 打印调试信息
print("FreakStudio: Using R60ABD1 millimeter wave information collection")

# 初始化UART0：TX=16, RX=17，波特率115200
uart = UART(0, baudrate=115200, tx=Pin(16), rx=Pin(17), timeout=0)

# 创建DataFlowProcessor实例
processor = DataFlowProcessor(uart)

# 创建R60ABD1实例
device = R60ABD1(processor, parse_interval=200)

success, product_model = device.query_product_model()
if success:
    print("Product Model: %s" % product_model)
else:
    print("Query Product Model failed")

time.sleep(0.5)

success, product_id = device.query_product_id()
if success:
    print("Product ID: %s" % product_id)
else:
    print("Query Product ID failed")

time.sleep(0.5)

success, hardware_model = device.query_hardware_model()
if success:
    print("Hardware Model: %s" % hardware_model)
else:
    print("Query Hardware Model failed")

time.sleep(0.5)

success, firmware_version = device.query_firmware_version()
if success:
    print("Hardware Version: %s" % firmware_version)
else:
    print("Query Hardware Version failed")

time.sleep(0.5)

success, init_status = device.query_init_complete()
if success:
    print("Init Status: %s" % init_status)
else:
    print("Query Init Status failed")

time.sleep(0.5)

success, boundary_status = device.query_radar_range_boundary()
if success:
    status_text = "out of range" if boundary_status else "in range"
    print("Boundary Status: %s" % status_text)
else:
    print("Query Boundary Status failed")

time.sleep(0.5)

success, presence_switch_status = device.query_human_presence_switch()
if success:
    status_text = "ON" if presence_switch_status else "OFF"
    print("Boundary Status: %s" % status_text)
else:
    print("Query Boundary Status failed")

time.sleep(0.5)

success, heart_rate_monitor_switch_status = device.query_heart_rate_monitor_switch()
if success:
    status_text = "ON" if heart_rate_monitor_switch_status else "OFF"
    print("Heart Rate Monitor Switch: %s" % status_text)
else:
    print("Query Heart Rate Monitor Switch failed")

time.sleep(0.5)

success, heart_rate_waveform_report_switch_status = device.query_heart_rate_waveform_report_switch()
if success:
    status_text = "ON" if heart_rate_waveform_report_switch_status else "OFF"
    print("Heart Rate Waveform Report Switch: %s" % status_text)
else:
    print("Query Heart Rate Waveform Report Switch failed")

time.sleep(0.5)

# 查询呼吸监测开关状态
success, breath_monitor_switch_status = device.query_breath_monitor_switch()
if success:
    status_text = "ON" if breath_monitor_switch_status else "OFF"
    print("Breath Monitor Switch: %s" % status_text)
else:
    print("Query Breath Monitor Switch failed")

time.sleep(0.5)

# 设置低缓呼吸阈值为15次/分
success, set_result = device.set_low_breath_threshold(15)
if success:
    print("Set Low Breath Threshold: Success (15 bpm)")
else:
    print("Set Low Breath Threshold failed")

time.sleep(0.5)

# 查询当前低缓呼吸阈值
success, low_breath_threshold = device.query_low_breath_threshold()
if success:
    print("Query Low Breath Threshold: %d bpm" % low_breath_threshold)
else:
    print("Query Low Breath Threshold failed")

time.sleep(0.5)

# 查询呼吸波形上报开关状态
success, breath_waveform_report_switch_status = device.query_breath_waveform_report_switch()
if success:
    status_text = "ON" if breath_waveform_report_switch_status else "OFF"
    print("Breath Waveform Report Switch: %s" % status_text)
else:
    print("Query Breath Waveform Report Switch failed")

# 查询睡眠监测开关状态
success, sleep_monitor_switch_status = device.query_sleep_monitor_switch()
if success:
    status_text = "ON" if sleep_monitor_switch_status else "OFF"
    print("Sleep Monitor Switch: %s" % status_text)
else:
    print("Query Sleep Monitor Switch failed")

time.sleep(0.5)

# 打开睡眠监测功能
success, result = device.enable_sleep_monitor()
if success:
    print("Enable Sleep Monitor: Success")
else:
    print("Enable Sleep Monitor failed")

time.sleep(0.5)

# 查询异常挣扎监测开关状态
success, abnormal_struggle_switch_status = device.query_abnormal_struggle_switch()
if success:
    status_text = "ON" if abnormal_struggle_switch_status else "OFF"
    print("Abnormal Struggle Monitor Switch: %s" % status_text)
else:
    print("Query Abnormal Struggle Monitor Switch failed")

time.sleep(0.5)

# 打开异常挣扎监测功能
success, result = device.enable_abnormal_struggle_monitor()
if success:
    print("Enable Abnormal Struggle Monitor: Success")
else:
    print("Enable Abnormal Struggle Monitor failed")

time.sleep(0.5)

# 查询挣扎灵敏度
success, struggle_sensitivity = device.query_struggle_sensitivity()
if success:
    sensitivity_text = ["Low", "Medium", "High"][struggle_sensitivity] if struggle_sensitivity < 3 else "Unknown"
    print("Struggle Sensitivity: %d - %s" % (struggle_sensitivity, sensitivity_text))
else:
    print("Query Struggle Sensitivity failed")

time.sleep(0.5)

# 设置挣扎灵敏度为中等
success, result = device.set_struggle_sensitivity(1)  # 1 = 中等灵敏度
if success:
    print("Set Struggle Sensitivity: Success (Medium)")
else:
    print("Set Struggle Sensitivity failed")

time.sleep(0.5)

# 查询无人计时功能开关状态
success, no_person_timing_switch_status = device.query_no_person_timing_switch()
if success:
    status_text = "ON" if no_person_timing_switch_status else "OFF"
    print("No Person Timing Switch: %s" % status_text)
else:
    print("Query No Person Timing Switch failed")

time.sleep(0.5)

# 打开无人计时功能
success, result = device.enable_no_person_timing()
if success:
    print("Enable No Person Timing: Success")
else:
    print("Enable No Person Timing failed")

time.sleep(0.5)

# 查询无人计时时长
success, no_person_timing_duration = device.query_no_person_timing_duration()
if success:
    print("No Person Timing Duration: %d minutes" % no_person_timing_duration)
else:
    print("Query No Person Timing Duration failed")

time.sleep(0.5)

# 设置无人计时时长为30分钟
success, result = device.set_no_person_timing_duration(30)
if success:
    print("Set No Person Timing Duration: Success (30 minutes)")
else:
    print("Set No Person Timing Duration failed")

time.sleep(0.5)

# 查询睡眠截止时长
success, sleep_end_duration = device.query_sleep_end_duration()
if success:
    print("Sleep End Duration: %d minutes" % sleep_end_duration)
else:
    print("Query Sleep End Duration failed")

time.sleep(0.5)

# 设置睡眠截止时长为10分钟
success, result = device.set_sleep_end_duration(10)
if success:
    print("Set Sleep End Duration: Success (10 minutes)")
else:
    print("Set Sleep End Duration failed")

time.sleep(0.5)

# ========================================  主程序  ===========================================

try:
    while True:
        current_time = time.ticks_ms()

        # 定期打印传感器数据
        if time.ticks_diff(current_time, last_print_time) >= print_interval:

            # print_report_sensor_data()

            success, presence_status = device.query_presence_status()
            if success:
                print("Presence Status: %s" % ("Someone" if presence_status == 1 else "No one"))
            else:
                print("Query Presence Status failed")
            last_print_time = current_time

            time.sleep(0.2)

            success, heartbeat_status = device.query_heartbeat()
            if success:
                print("Heartbeat Status: %s" % ("Normal" if heartbeat_status == 1 else "Abnormal"))
            else:
                print("Query Heartbeat failed")

        # 小延迟，避免占用太多CPU
        time.sleep_ms(10)

except KeyboardInterrupt:
    print("%s Program interrupted by user" % format_time())

finally:
    # 清理资源
    print("%s Cleaning up resources..." % format_time())
    # 停止实例运行
    device.close()
    # 销毁实例
    del device
    print("%s Program exited" % format_time())

4.3 Performance Testing and System Resource Analysis

# 计时装饰器，用于计算函数运行时间
def timed_function(f: callable, *args: tuple, **kwargs: dict) -> callable:
    """
    计时装饰器，用于计算并打印函数/方法运行时间。

    Args:
        f (callable): 需要传入的函数/方法
        args (tuple): 函数/方法 f 传入的任意数量的位置参数
        kwargs (dict): 函数/方法 f 传入的任意数量的关键字参数

    Returns:
        callable: 返回计时后的函数
    """
    myname = str(f).split(' ')[1]

    def new_func(*args: tuple, **kwargs: dict) -> any:
        t: int = time.ticks_us()
        result = f(*args, **kwargs)
        delta: int = time.ticks_diff(time.ticks_us(), t)
        print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000))
        return result

    return new_func

Function update_properties_from_frame Time = 0.287ms
Function update_properties_from_frame Time = 0.164ms
Function update_properties_from_frame Time = 0.625ms
...