NRF24模块有效载荷限制与多数据包传输策略

import struct
import time
from queue import Queue # 假设数据来自一个队列

# 模拟pyNRF库的nrf对象
class MockNRF:
    def __init__(self):
        self.sent_packets = []
        self.lost_packages = 0
        self.retries = 0

    def reset_packages_lost(self):
        self.lost_packages = 0

    def send(self, payload):
        print(f"[Sender] Sending payload (len={len(payload)}): {payload[:10]}...")
        self.sent_packets.append(payload)
        # 模拟传输延迟
        time.sleep(0.05)

    def wait_until_sent(self):
        # 模拟等待发送完成
        pass

    def get_packages_lost(self):
        return self.lost_packages

    def get_retries(self):
        return self.retries

# NRF24模块最大有效载荷为32字节
MAX_NRF24_PAYLOAD_SIZE = 32
# 为协议头预留空间，实际数据部分最大长度
DATA_CHUNK_SIZE = MAX_NRF24_PAYLOAD_SIZE - 2 # 预留2字节给 [chunk_idx, is_last]

nrf = MockNRF() # 实际应用中替换为pyNRF的nrf对象

def send_large_data(nrf_obj, message_id, data_bytes):
    """
    将大块数据分块并通过NRF24发送。
    协议头：[chunk_idx (1B), is_last_chunk (1B)]
    """
    total_len = len(data_bytes)
    num_chunks = (total_len + DATA_CHUNK_SIZE - 1) // DATA_CHUNK_SIZE

    print(f"\n[Sender] Preparing to send {total_len} bytes in {num_chunks} chunks (Message ID: {message_id}).")

    for i in range(num_chunks):
        start = i * DATA_CHUNK_SIZE
        end = min((i + 1) * DATA_CHUNK_SIZE, total_len)
        chunk_data_segment = data_bytes[start:end]

        is_last_chunk = 1 if i == num_chunks - 1 else 0

        # 协议头: [chunk_idx (1B), is_last_chunk (1B)]
        header = struct.pack("<BB", i, is_last_chunk)
        payload = header + chunk_data_segment

        # 确保每个payload不超过NRF24限制
        if len(payload) > MAX_NRF24_PAYLOAD_SIZE:
            print(f"[Error] Chunk {i} payload size {len(payload)} exceeds max NRF24 payload {MAX_NRF24_PAYLOAD_SIZE}!")
            return False

        nrf_obj.reset_packages_lost()
        nrf_obj.send(payload)

        try:
            nrf_obj.wait_until_sent()
            print(f"[Sender] Chunk {i}/{num_chunks-1} sent successfully. (Payload len: {len(payload)})")
        except TimeoutError:
            print(f"[Sender] Timed out sending chunk {i}. Retrying...")
            # 实际应用中需要更复杂的重传逻辑
            time.sleep(0.2)
            continue

        if nrf_obj.get_packages_lost() == 0:
            # print(f"Success: lost={nrf_obj.get_packages_lost()}, retries={nrf_obj.get_retries()}")
            pass
        else:
            print(f"Error: lost={nrf_obj.get_packages_lost()}, retries={nrf_obj.get_retries()}")

        time.sleep(0.1) # 模拟发送间隔
    return True

# 示例数据
large_string_data = "This is a very long message that needs to be broken into multiple chunks to be sent over NRF24. It contains important information about sensor readings and device status."
large_byte_data = large_string_data.encode('utf-8')

# 发送数据
send_large_data(nrf, 0x01, large_byte_data)

# 模拟发送第二个大块数据
another_large_data = b"Another important data block with different content."
send_large_data(nrf, 0x02, another_large_data)

import struct
from datetime import datetime

# 模拟pyNRF库的nrf对象
class MockNRFReceiver:
    def __init__(self, sent_packets):
        self.received_queue = sent_packets # 模拟从发送端接收到的数据
        self.current_idx = 0

    def data_ready(self):
        return self.current_idx < len(self.received_queue)

    def data_pipe(self):
        return 0 # 模拟管道号

    def get_payload(self):
        if self.data_ready():
            payload = self.received_queue[self.current_idx]
            self.current_idx += 1
            return payload
        return None

    def show_registers(self):
        # 模拟显示寄存器信息
        pass

# 假设nrf_receiver是实际pyNRF的nrf对象
nrf_receiver = MockNRFReceiver(nrf.sent_packets) # 从发送端的模拟队列获取数据

# 用于存储正在重组的大块数据
# 结构: {message_id: {chunk_idx: payload_data_segment, ...}, ...}
received_messages_buffer = {}

# 存储完整重组后的消息
completed_messages = Queue()

print("\n[Receiver] Starting to listen for data...")

while True:
    while nrf_receiver.data_ready():
        now = datetime.now()
        pipe = nrf_receiver.data_pipe()
        payload = nrf_receiver.get_payload()

        if payload is None or len(payload) < 2: # 至少需要2字节的协议头
            print(f"{now:%Y-%m-%d %H:%M:%S.%f}: pipe: {pipe}, len: {len(payload) if payload else 0}, Invalid payload received.")
            continue

        # 解析协议头
        try:
            chunk_idx, is_last_chunk = struct.unpack("<BB", payload[0:2])
            data_segment = payload[2:] # 实际数据部分

            # 假设message_id在发送端逻辑中被隐式处理，或者通过另一个字节传输
            # 这里我们直接使用一个固定的message_id来模拟，或者在协议头中增加message_id
            # 为了匹配发送端，我们假定发送端是按顺序发送且知道message_id
            # 实际应用中，message_id也应在payload中
            # 这里为了简化，我们假设接收端知道当前正在接收哪个message_id的数据
            # 假设第一个大块数据的message_id是0x01，第二个是0x02
            # 实际中，message_id也应该从payload中解析出来

            # 为了匹配发送端，这里需要一个机制来知道当前是哪个message_id
            # 假设我们从payload的第一个字节（0x01或0x02）来判断message_id
            # 这是为了适应原始问题中payload[0] == 0x01的检查
            # 实际应用中，message_id应该是协议头的一部分
            message_id = 0x01 if nrf_receiver.current_idx <= (len(nrf.sent_packets) / 2) else 0x02 # 这是一个hack，实际需要从payload解析

            print(f"{now:%Y-%m-%d %H:%M:%S.%f}: pipe: {pipe}, len: {len(payload)}, "
                  f"MsgID: {message_id}, Chunk: {chunk_idx}, Last: {bool(is_last_chunk)}, "
                  f"Data len: {len(data_segment)}")

            if message_id not in received_messages_buffer:
                received_messages_buffer[message_id] = {}

            received_messages_buffer[message_id][chunk_idx] = data_segment

            if is_last_chunk:
                # 检查是否所有块都已收到
                sorted_chunks = sorted(received_messages_buffer[message_id].items())

                # 检查块的连续性
                if all(idx == i for i, (idx, _) in enumerate(sorted_chunks)):
                    full_data = b"".join([data for idx, data in sorted_chunks])
                    completed_messages.put_nowait((message_id, full_data))
                    print(f"[Receiver] Reassembled Message ID {message_id} (len: {len(full_data)}) successfully: {full_data.decode('utf-8', errors='ignore')[:50]}...")
                    del received_messages_buffer[message_id] # 清除缓冲区
                else:
                    print(f"[Receiver] Warning: Message ID {message_id} received last chunk, but chunks are not continuous or missing.")
        except struct.error as e:
            print(f"[Receiver] Struct unpack error: {e}. Payload: {payload}")
        except Exception as e:
            print(f"[Receiver] An error occurred: {e}")

    # 处理已完成的消息
    while not completed_messages.empty():
        msg_id, data = completed_messages.get_nowait()
        print(f"\n[Receiver] --- FINAL PROCESSED MESSAGE ---")
        print(f"  Message ID: {msg_id}")
        print(f"  Data Length: {len(data)} bytes")
        print(f"  Decoded: {data.decode('utf-8', errors='ignore')}")
        print(f"-------------------------------------\n")

    time.sleep(0.1)

    # 模拟接收结束，在实际应用中，这将是一个无限循环
    if nrf_receiver.current_idx >= len(nrf.sent_packets):
        print("[Receiver] All simulated packets processed. Exiting.")
        break