{

radio.begin();

radio.enableDynamicPayloads();

radio.setRetries(2,1);

radio.setRetries(4,2);

radio.openReadingPipe(1,TO_BROADCAST(PEER_DISCOVERY));

radio.setAutoAck(0,true);

radio.setAutoAck(1,false);

const MeshBase::MessageHeader* header = (structMeshBase::MessageHeader*)data;

uint8_t payload_length = len -sizeof(MessageHeader);

const byte* payload = data +sizeof(MessageHeader);

if (header->protocol_version !=1)

return;

Message* s = assembly_list.Find<const MessageHeader*>(header, &FindStream);

if (s ==NULL) {

s =newMessage(*header);

msg->split_part = num;

msg->split_more = remaining_length > MAX_PAYLOAD_SIZE;

memcpy(buff +sizeof(MessageHeader), (const byte*)data + (num * MAX_PAYLOAD_SIZE),min(remaining_length, MAX_PAYLOAD_SIZE));

uint8_t wire_size =min(remaining_length +sizeof(MessageHeader), MAX_PACKET_SIZE);

radio.stopListening();

bool result =true;

if (is_broadcast)

radio.openWritingPipe(TO_BROADCAST(to));

radio.openWritingPipe(TO_ADDRESS(to));

radio.write(buff,min(remaining_length +sizeof(MessageHeader), MAX_PACKET_SIZE));

if (is_broadcast) {

result = radio.write(buff, wire_size);

}else {

result = radio.write(buff, wire_size);

}

radio.startListening();

Serial.print(" T Sending pkt split_part=");

Serial.print(msg->split_part);

Serial.print(" split_more=");

Serial.print(msg->split_more);

Serial.print(" length=");

Serial.println(min(remaining_length, MAX_PAYLOAD_SIZE));

if (!is_broadcast)

{

Serial.print(" T Sending pkt split_part=");

Serial.print(msg->split_part);

Serial.print(" result=");

Serial.println(result);

}

delay(100);

}

}

Peer(uint32_t address) : address(address), time(0) {}

};

{

structMessageHeader {

uint8_tprotocol_version :4;

uint8_tttl :4;

uint8_tmsg_id;

voidBegin();

voidUpdate();

voidSendMessage(uint32_t address,uint8_t type,constvoid* data,uint8_t length);

voidSendMessage(uint32_t address,uint8_t type,constvoid* data,uint8_t length,bool is_broadcast);

uint32_tGetAddress()const {return address; }

boolIsReady()const {return address !=0; }

unsignedlonglast_peer_check_time;

voidSendPeerDiscovery();

voidSendMessage(uint32_t address,uint8_t type,constvoid* data,uint8_t length,bool is_broadcast);

voidHandlePeerDiscovery(const MessageHeader* msg,constvoid* buff,uint8_t length);

voidHandlePacket(const byte* data,uint8_t length);

voidChooseAddress();