pieter Berteloot
fd
Dependents: xtoff3 CYS_Receiver
Fork of
RF24Network
by 
Akash Vibhute
RF24Network.cpp@7:d72e1d8f5355, 2018-09-13 (annotated)
- Committer:
- pietor
- Date:
- Thu Sep 13 09:14:42 2018 +0000
- Revision:
- 7:d72e1d8f5355
- Parent:
- 6:80195a45b25c
Who changed what in which revision?
| User | Revision | Line number | New contents of line |
|---|---|---|---|
| akashvibhute | 0:c3db0798d9aa | 1 | /* |
| akashvibhute | 0:c3db0798d9aa | 2 | Copyright (C) 2011 James Coliz, Jr. <maniacbug@ymail.com> |
| akashvibhute | 0:c3db0798d9aa | 3 | |
| akashvibhute | 0:c3db0798d9aa | 4 | This program is free software; you can redistribute it and/or |
| akashvibhute | 0:c3db0798d9aa | 5 | modify it under the terms of the GNU General Public License |
| akashvibhute | 0:c3db0798d9aa | 6 | version 2 as published by the Free Software Foundation. |
| akashvibhute | 0:c3db0798d9aa | 7 | */ |
| akashvibhute | 0:c3db0798d9aa | 8 | |
| akashvibhute | 3:dfc8da7ac18c | 9 | /* |
| akashvibhute | 3:dfc8da7ac18c | 10 | * Mbed support added by Akash Vibhute <akash.roboticist@gmail.com> |
| akashvibhute | 3:dfc8da7ac18c | 11 | * Porting completed on Nov/05/2015 |
| akashvibhute | 3:dfc8da7ac18c | 12 | * |
| akashvibhute | 3:dfc8da7ac18c | 13 | * Updated with TMRh20's RF24 library on Nov/04/2015 from https://github.com/TMRh20 |
| akashvibhute | 3:dfc8da7ac18c | 14 | * |
| akashvibhute | 3:dfc8da7ac18c | 15 | */ |
| akashvibhute | 2:a5f8e04bd02b | 16 | |
| akashvibhute | 3:dfc8da7ac18c | 17 | #include "RF24Network_config.h" |
| akashvibhute | 0:c3db0798d9aa | 18 | #include <RF24.h> |
| akashvibhute | 0:c3db0798d9aa | 19 | #include "RF24Network.h" |
| akashvibhute | 0:c3db0798d9aa | 20 | |
| akashvibhute | 2:a5f8e04bd02b | 21 | uint16_t RF24NetworkHeader::next_id = 1; |
| akashvibhute | 2:a5f8e04bd02b | 22 | #if defined ENABLE_NETWORK_STATS |
| akashvibhute | 2:a5f8e04bd02b | 23 | uint32_t RF24Network::nFails = 0; |
| akashvibhute | 2:a5f8e04bd02b | 24 | uint32_t RF24Network::nOK = 0; |
| akashvibhute | 2:a5f8e04bd02b | 25 | #endif |
| akashvibhute | 0:c3db0798d9aa | 26 | uint64_t pipe_address( uint16_t node, uint8_t pipe ); |
| akashvibhute | 2:a5f8e04bd02b | 27 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 2:a5f8e04bd02b | 28 | uint16_t levelToAddress( uint8_t level ); |
| akashvibhute | 2:a5f8e04bd02b | 29 | #endif |
| akashvibhute | 0:c3db0798d9aa | 30 | bool is_valid_address( uint16_t node ); |
| akashvibhute | 0:c3db0798d9aa | 31 | |
| pietor | 7:d72e1d8f5355 | 32 | |
| pietor | 7:d72e1d8f5355 | 33 | |
| akashvibhute | 0:c3db0798d9aa | 34 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 35 | #if !defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 36 | RF24Network::RF24Network( RF24& _radio ): radio(_radio), next_frame(frame_queue) |
| akashvibhute | 0:c3db0798d9aa | 37 | { |
| akashvibhute | 3:dfc8da7ac18c | 38 | #if !defined ( DISABLE_FRAGMENTATION ) |
| akashvibhute | 3:dfc8da7ac18c | 39 | frag_queue.message_buffer=&frag_queue_message_buffer[0]; |
| akashvibhute | 3:dfc8da7ac18c | 40 | frag_ptr = &frag_queue; |
| akashvibhute | 3:dfc8da7ac18c | 41 | #endif |
| akashvibhute | 0:c3db0798d9aa | 42 | } |
| akashvibhute | 2:a5f8e04bd02b | 43 | #else |
| akashvibhute | 2:a5f8e04bd02b | 44 | RF24Network::RF24Network( RF24& _radio, RF24& _radio1 ): radio(_radio), radio1(_radio1), next_frame(frame_queue) |
| akashvibhute | 2:a5f8e04bd02b | 45 | { |
| akashvibhute | 3:dfc8da7ac18c | 46 | #if !defined ( DISABLE_FRAGMENTATION ) |
| akashvibhute | 3:dfc8da7ac18c | 47 | frag_queue.message_buffer=&frag_queue_message_buffer[0]; |
| akashvibhute | 3:dfc8da7ac18c | 48 | frag_ptr = &frag_queue; |
| akashvibhute | 3:dfc8da7ac18c | 49 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 50 | } |
| akashvibhute | 2:a5f8e04bd02b | 51 | #endif |
| akashvibhute | 0:c3db0798d9aa | 52 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 53 | |
| akashvibhute | 0:c3db0798d9aa | 54 | void RF24Network::begin(uint8_t _channel, uint16_t _node_address ) |
| akashvibhute | 0:c3db0798d9aa | 55 | { |
| akashvibhute | 3:dfc8da7ac18c | 56 | rf24netTimer.start(); |
| akashvibhute | 3:dfc8da7ac18c | 57 | if (! is_valid_address(_node_address) ) |
| akashvibhute | 3:dfc8da7ac18c | 58 | return; |
| akashvibhute | 0:c3db0798d9aa | 59 | |
| akashvibhute | 3:dfc8da7ac18c | 60 | node_address = _node_address; |
| akashvibhute | 3:dfc8da7ac18c | 61 | |
| akashvibhute | 3:dfc8da7ac18c | 62 | if ( ! radio.isValid() ) { |
| akashvibhute | 3:dfc8da7ac18c | 63 | return; |
| akashvibhute | 3:dfc8da7ac18c | 64 | } |
| akashvibhute | 0:c3db0798d9aa | 65 | |
| akashvibhute | 3:dfc8da7ac18c | 66 | // Set up the radio the way we want it to look |
| akashvibhute | 3:dfc8da7ac18c | 67 | if(_channel != USE_CURRENT_CHANNEL) { |
| akashvibhute | 3:dfc8da7ac18c | 68 | radio.setChannel(_channel); |
| akashvibhute | 3:dfc8da7ac18c | 69 | } |
| akashvibhute | 3:dfc8da7ac18c | 70 | //radio.enableDynamicAck(); |
| akashvibhute | 3:dfc8da7ac18c | 71 | radio.setAutoAck(0,0); |
| akashvibhute | 3:dfc8da7ac18c | 72 | |
| akashvibhute | 3:dfc8da7ac18c | 73 | #if defined (ENABLE_DYNAMIC_PAYLOADS) |
| akashvibhute | 3:dfc8da7ac18c | 74 | radio.enableDynamicPayloads(); |
| akashvibhute | 3:dfc8da7ac18c | 75 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 76 | |
| akashvibhute | 3:dfc8da7ac18c | 77 | // Use different retry periods to reduce data collisions |
| akashvibhute | 3:dfc8da7ac18c | 78 | uint8_t retryVar = (((node_address % 6)+1) *2) + 3; |
| akashvibhute | 3:dfc8da7ac18c | 79 | radio.setRetries(retryVar, 5); |
| akashvibhute | 3:dfc8da7ac18c | 80 | txTimeout = 25; |
| akashvibhute | 3:dfc8da7ac18c | 81 | routeTimeout = txTimeout*9; // Adjust for max delay per node |
| akashvibhute | 2:a5f8e04bd02b | 82 | |
| akashvibhute | 2:a5f8e04bd02b | 83 | |
| akashvibhute | 2:a5f8e04bd02b | 84 | #if defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 85 | radio1.setChannel(_channel); |
| akashvibhute | 3:dfc8da7ac18c | 86 | radio1.enableDynamicAck(); |
| akashvibhute | 3:dfc8da7ac18c | 87 | radio1.enableDynamicPayloads(); |
| akashvibhute | 2:a5f8e04bd02b | 88 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 89 | |
| akashvibhute | 3:dfc8da7ac18c | 90 | // Setup our address helper cache |
| akashvibhute | 3:dfc8da7ac18c | 91 | setup_address(); |
| akashvibhute | 2:a5f8e04bd02b | 92 | |
| akashvibhute | 3:dfc8da7ac18c | 93 | // Open up all listening pipes |
| akashvibhute | 3:dfc8da7ac18c | 94 | uint8_t i = 6; |
| akashvibhute | 3:dfc8da7ac18c | 95 | while (i--) { |
| akashvibhute | 3:dfc8da7ac18c | 96 | radio.openReadingPipe(i,pipe_address(_node_address,i)); |
| akashvibhute | 3:dfc8da7ac18c | 97 | } |
| akashvibhute | 3:dfc8da7ac18c | 98 | radio.startListening(); |
| akashvibhute | 3:dfc8da7ac18c | 99 | |
| akashvibhute | 0:c3db0798d9aa | 100 | } |
| akashvibhute | 0:c3db0798d9aa | 101 | |
| akashvibhute | 0:c3db0798d9aa | 102 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 103 | |
| akashvibhute | 2:a5f8e04bd02b | 104 | #if defined ENABLE_NETWORK_STATS |
| akashvibhute | 3:dfc8da7ac18c | 105 | void RF24Network::failures(uint32_t *_fails, uint32_t *_ok) |
| akashvibhute | 3:dfc8da7ac18c | 106 | { |
| akashvibhute | 2:a5f8e04bd02b | 107 | *_fails = nFails; |
| akashvibhute | 2:a5f8e04bd02b | 108 | *_ok = nOK; |
| akashvibhute | 2:a5f8e04bd02b | 109 | } |
| akashvibhute | 2:a5f8e04bd02b | 110 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 111 | |
| akashvibhute | 2:a5f8e04bd02b | 112 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 113 | |
| akashvibhute | 2:a5f8e04bd02b | 114 | uint8_t RF24Network::update(void) |
| akashvibhute | 0:c3db0798d9aa | 115 | { |
| akashvibhute | 3:dfc8da7ac18c | 116 | // if there is data ready |
| akashvibhute | 3:dfc8da7ac18c | 117 | uint8_t pipe_num; |
| akashvibhute | 3:dfc8da7ac18c | 118 | uint8_t returnVal = 0; |
| akashvibhute | 3:dfc8da7ac18c | 119 | |
| akashvibhute | 3:dfc8da7ac18c | 120 | // If bypass is enabled, continue although incoming user data may be dropped |
| akashvibhute | 3:dfc8da7ac18c | 121 | // Allows system payloads to be read while user cache is full |
| akashvibhute | 3:dfc8da7ac18c | 122 | // Incoming Hold prevents data from being read from the radio, preventing incoming payloads from being acked |
| akashvibhute | 3:dfc8da7ac18c | 123 | |
| akashvibhute | 2:a5f8e04bd02b | 124 | |
| akashvibhute | 3:dfc8da7ac18c | 125 | if(!(networkFlags & FLAG_BYPASS_HOLDS)) { |
| akashvibhute | 3:dfc8da7ac18c | 126 | if( (networkFlags & FLAG_HOLD_INCOMING) || (next_frame-frame_queue) + 34 > MAIN_BUFFER_SIZE ) { |
| akashvibhute | 3:dfc8da7ac18c | 127 | if(!available()) { |
| akashvibhute | 3:dfc8da7ac18c | 128 | networkFlags &= ~FLAG_HOLD_INCOMING; |
| akashvibhute | 3:dfc8da7ac18c | 129 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 130 | return 0; |
| akashvibhute | 3:dfc8da7ac18c | 131 | } |
| akashvibhute | 3:dfc8da7ac18c | 132 | } |
| akashvibhute | 2:a5f8e04bd02b | 133 | } |
| akashvibhute | 3:dfc8da7ac18c | 134 | |
| akashvibhute | 2:a5f8e04bd02b | 135 | |
| akashvibhute | 3:dfc8da7ac18c | 136 | while ( radio.isValid() && radio.available(&pipe_num) ) { |
| akashvibhute | 0:c3db0798d9aa | 137 | |
| akashvibhute | 3:dfc8da7ac18c | 138 | #if defined (ENABLE_DYNAMIC_PAYLOADS) |
| akashvibhute | 3:dfc8da7ac18c | 139 | if( (frame_size = radio.getDynamicPayloadSize() ) < sizeof(RF24NetworkHeader)) { |
| akashvibhute | 3:dfc8da7ac18c | 140 | wait_ms(10); |
| akashvibhute | 3:dfc8da7ac18c | 141 | continue; |
| akashvibhute | 3:dfc8da7ac18c | 142 | } |
| akashvibhute | 3:dfc8da7ac18c | 143 | #else |
| akashvibhute | 3:dfc8da7ac18c | 144 | frame_size=32; |
| akashvibhute | 3:dfc8da7ac18c | 145 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 146 | // Dump the payloads until we've gotten everything |
| akashvibhute | 3:dfc8da7ac18c | 147 | // Fetch the payload, and see if this was the last one. |
| akashvibhute | 3:dfc8da7ac18c | 148 | radio.read( frame_buffer, frame_size ); |
| akashvibhute | 3:dfc8da7ac18c | 149 | |
| akashvibhute | 3:dfc8da7ac18c | 150 | // Read the beginning of the frame as the header |
| akashvibhute | 3:dfc8da7ac18c | 151 | RF24NetworkHeader *header = (RF24NetworkHeader*)(&frame_buffer); |
| akashvibhute | 3:dfc8da7ac18c | 152 | |
| pietor | 6:80195a45b25c | 153 | IF_SERIAL_DEBUG(printf_P(PSTR("%lu: MAC Received %s\n\r"),pipe_num,header->toString())); |
| pietor | 6:80195a45b25c | 154 | IF_SERIAL_DEBUG(const uint16_t* i = reinterpret_cast<const uint16_t*>(frame_buffer + sizeof(RF24NetworkHeader)); printf_P(PSTR("%lu: NET message %04x\n\r"),*i)); |
| akashvibhute | 0:c3db0798d9aa | 155 | |
| akashvibhute | 3:dfc8da7ac18c | 156 | |
| akashvibhute | 3:dfc8da7ac18c | 157 | // Throw it away if it's not a valid address |
| akashvibhute | 3:dfc8da7ac18c | 158 | if ( !is_valid_address(header->to_node) ) { |
| akashvibhute | 3:dfc8da7ac18c | 159 | continue; |
| akashvibhute | 3:dfc8da7ac18c | 160 | } |
| akashvibhute | 3:dfc8da7ac18c | 161 | |
| akashvibhute | 3:dfc8da7ac18c | 162 | uint8_t returnVal = header->type; |
| akashvibhute | 0:c3db0798d9aa | 163 | |
| akashvibhute | 3:dfc8da7ac18c | 164 | // Is this for us? |
| akashvibhute | 3:dfc8da7ac18c | 165 | if ( header->to_node == node_address ) { |
| akashvibhute | 0:c3db0798d9aa | 166 | |
| akashvibhute | 3:dfc8da7ac18c | 167 | if(header->type == NETWORK_PING) { |
| akashvibhute | 3:dfc8da7ac18c | 168 | continue; |
| akashvibhute | 2:a5f8e04bd02b | 169 | } |
| akashvibhute | 3:dfc8da7ac18c | 170 | if(header->type == NETWORK_ADDR_RESPONSE ) { |
| akashvibhute | 3:dfc8da7ac18c | 171 | uint16_t requester = frame_buffer[8]; |
| akashvibhute | 2:a5f8e04bd02b | 172 | requester |= frame_buffer[9] << 8; |
| akashvibhute | 3:dfc8da7ac18c | 173 | if(requester != node_address) { |
| akashvibhute | 2:a5f8e04bd02b | 174 | header->to_node = requester; |
| akashvibhute | 2:a5f8e04bd02b | 175 | write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS); |
| akashvibhute | 2:a5f8e04bd02b | 176 | wait_ms(10); |
| akashvibhute | 2:a5f8e04bd02b | 177 | write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS); |
| akashvibhute | 2:a5f8e04bd02b | 178 | //printf("Fwd add response to 0%o\n",requester); |
| akashvibhute | 2:a5f8e04bd02b | 179 | continue; |
| akashvibhute | 2:a5f8e04bd02b | 180 | } |
| akashvibhute | 2:a5f8e04bd02b | 181 | } |
| akashvibhute | 3:dfc8da7ac18c | 182 | if(header->type == NETWORK_REQ_ADDRESS && node_address) { |
| akashvibhute | 2:a5f8e04bd02b | 183 | //printf("Fwd add req to 0\n"); |
| akashvibhute | 2:a5f8e04bd02b | 184 | header->from_node = node_address; |
| akashvibhute | 2:a5f8e04bd02b | 185 | header->to_node = 0; |
| akashvibhute | 2:a5f8e04bd02b | 186 | write(header->to_node,TX_NORMAL); |
| akashvibhute | 2:a5f8e04bd02b | 187 | continue; |
| akashvibhute | 2:a5f8e04bd02b | 188 | } |
| akashvibhute | 3:dfc8da7ac18c | 189 | |
| akashvibhute | 3:dfc8da7ac18c | 190 | if( (returnSysMsgs && header->type > 127) || header->type == NETWORK_ACK ) { |
| akashvibhute | 2:a5f8e04bd02b | 191 | //IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%lu MAC: System payload rcvd %d\n"),millis(),returnVal); ); |
| akashvibhute | 2:a5f8e04bd02b | 192 | //if( (header->type < 148 || header->type > 150) && header->type != NETWORK_MORE_FRAGMENTS_NACK && header->type != EXTERNAL_DATA_TYPE && header->type!= NETWORK_LAST_FRAGMENT){ |
| akashvibhute | 3:dfc8da7ac18c | 193 | if( header->type != NETWORK_FIRST_FRAGMENT && header->type != NETWORK_MORE_FRAGMENTS && header->type != NETWORK_MORE_FRAGMENTS_NACK && header->type != EXTERNAL_DATA_TYPE && header->type!= NETWORK_LAST_FRAGMENT) { |
| akashvibhute | 2:a5f8e04bd02b | 194 | return returnVal; |
| akashvibhute | 2:a5f8e04bd02b | 195 | } |
| akashvibhute | 2:a5f8e04bd02b | 196 | } |
| akashvibhute | 0:c3db0798d9aa | 197 | |
| akashvibhute | 3:dfc8da7ac18c | 198 | if( enqueue(header) == 2 ) { //External data received |
| akashvibhute | 3:dfc8da7ac18c | 199 | #if defined (SERIAL_DEBUG_MINIMAL) |
| akashvibhute | 3:dfc8da7ac18c | 200 | printf("ret ext\n"); |
| akashvibhute | 3:dfc8da7ac18c | 201 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 202 | return EXTERNAL_DATA_TYPE; |
| akashvibhute | 2:a5f8e04bd02b | 203 | } |
| akashvibhute | 3:dfc8da7ac18c | 204 | } else { |
| akashvibhute | 2:a5f8e04bd02b | 205 | |
| akashvibhute | 3:dfc8da7ac18c | 206 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 2:a5f8e04bd02b | 207 | |
| akashvibhute | 3:dfc8da7ac18c | 208 | if( header->to_node == 0100) { |
| akashvibhute | 0:c3db0798d9aa | 209 | |
| akashvibhute | 3:dfc8da7ac18c | 210 | |
| akashvibhute | 3:dfc8da7ac18c | 211 | if(header->type == NETWORK_POLL ) { |
| akashvibhute | 2:a5f8e04bd02b | 212 | //Serial.println("Send poll"); |
| akashvibhute | 2:a5f8e04bd02b | 213 | header->to_node = header->from_node; |
| akashvibhute | 3:dfc8da7ac18c | 214 | header->from_node = node_address; |
| akashvibhute | 2:a5f8e04bd02b | 215 | //delay((node_address%5)*3); |
| akashvibhute | 2:a5f8e04bd02b | 216 | write(header->to_node,USER_TX_TO_PHYSICAL_ADDRESS); |
| akashvibhute | 2:a5f8e04bd02b | 217 | continue; |
| akashvibhute | 2:a5f8e04bd02b | 218 | } |
| akashvibhute | 2:a5f8e04bd02b | 219 | uint8_t val = enqueue(header); |
| akashvibhute | 3:dfc8da7ac18c | 220 | |
| akashvibhute | 3:dfc8da7ac18c | 221 | if(multicastRelay) { |
| akashvibhute | 2:a5f8e04bd02b | 222 | //IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%u MAC: FWD multicast frame from 0%o to level %u\n"),millis(),header->from_node,multicast_level+1); ); |
| akashvibhute | 2:a5f8e04bd02b | 223 | write(levelToAddress(multicast_level)<<3,4); |
| akashvibhute | 2:a5f8e04bd02b | 224 | } |
| akashvibhute | 3:dfc8da7ac18c | 225 | if( val == 2 ) { //External data received |
| akashvibhute | 3:dfc8da7ac18c | 226 | //Serial.println("ret ext multicast"); |
| akashvibhute | 2:a5f8e04bd02b | 227 | return EXTERNAL_DATA_TYPE; |
| akashvibhute | 2:a5f8e04bd02b | 228 | } |
| akashvibhute | 2:a5f8e04bd02b | 229 | |
| akashvibhute | 3:dfc8da7ac18c | 230 | } else { |
| akashvibhute | 2:a5f8e04bd02b | 231 | write(header->to_node,1); //Send it on, indicate it is a routed payload |
| akashvibhute | 2:a5f8e04bd02b | 232 | } |
| akashvibhute | 3:dfc8da7ac18c | 233 | #else |
| akashvibhute | 3:dfc8da7ac18c | 234 | write(header->to_node,1); //Send it on, indicate it is a routed payload |
| akashvibhute | 3:dfc8da7ac18c | 235 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 236 | } |
| akashvibhute | 3:dfc8da7ac18c | 237 | |
| akashvibhute | 3:dfc8da7ac18c | 238 | } |
| akashvibhute | 3:dfc8da7ac18c | 239 | return returnVal; |
| akashvibhute | 0:c3db0798d9aa | 240 | } |
| akashvibhute | 0:c3db0798d9aa | 241 | |
| akashvibhute | 2:a5f8e04bd02b | 242 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 243 | |
| akashvibhute | 2:a5f8e04bd02b | 244 | uint8_t RF24Network::enqueue(RF24NetworkHeader* header) |
| akashvibhute | 0:c3db0798d9aa | 245 | { |
| akashvibhute | 3:dfc8da7ac18c | 246 | bool result = false; |
| akashvibhute | 3:dfc8da7ac18c | 247 | uint8_t message_size = frame_size - sizeof(RF24NetworkHeader); |
| akashvibhute | 3:dfc8da7ac18c | 248 | |
| pietor | 6:80195a45b25c | 249 | IF_SERIAL_DEBUG(printf_P(PSTR("u: NET Enqueue @%x "),next_frame-frame_queue)); |
| akashvibhute | 3:dfc8da7ac18c | 250 | |
| akashvibhute | 3:dfc8da7ac18c | 251 | #if !defined ( DISABLE_FRAGMENTATION ) |
| akashvibhute | 2:a5f8e04bd02b | 252 | |
| akashvibhute | 3:dfc8da7ac18c | 253 | bool isFragment = header->type == NETWORK_FIRST_FRAGMENT || header->type == NETWORK_MORE_FRAGMENTS || header->type == NETWORK_LAST_FRAGMENT || header->type == NETWORK_MORE_FRAGMENTS_NACK ; |
| akashvibhute | 2:a5f8e04bd02b | 254 | |
| akashvibhute | 3:dfc8da7ac18c | 255 | if(isFragment) { |
| akashvibhute | 2:a5f8e04bd02b | 256 | |
| akashvibhute | 3:dfc8da7ac18c | 257 | if(header->type == NETWORK_FIRST_FRAGMENT) { |
| akashvibhute | 3:dfc8da7ac18c | 258 | // Drop frames exceeding max size and duplicates (MAX_PAYLOAD_SIZE needs to be divisible by 24) |
| akashvibhute | 3:dfc8da7ac18c | 259 | if(header->reserved > (MAX_PAYLOAD_SIZE / max_frame_payload_size) ) { |
| akashvibhute | 2:a5f8e04bd02b | 260 | |
| akashvibhute | 3:dfc8da7ac18c | 261 | #if defined (SERIAL_DEBUG_FRAGMENTATION) || defined (SERIAL_DEBUG_MINIMAL) |
| akashvibhute | 3:dfc8da7ac18c | 262 | printf_P(PSTR("Frag frame with %d frags exceeds MAX_PAYLOAD_SIZE or out of sequence\n"),header->reserved); |
| akashvibhute | 3:dfc8da7ac18c | 263 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 264 | frag_queue.header.reserved = 0; |
| akashvibhute | 3:dfc8da7ac18c | 265 | return false; |
| akashvibhute | 3:dfc8da7ac18c | 266 | } else if(frag_queue.header.id == header->id && frag_queue.header.from_node == header->from_node) { |
| akashvibhute | 3:dfc8da7ac18c | 267 | return true; |
| akashvibhute | 3:dfc8da7ac18c | 268 | } |
| akashvibhute | 3:dfc8da7ac18c | 269 | |
| akashvibhute | 3:dfc8da7ac18c | 270 | if( (header->reserved * 24) > (MAX_PAYLOAD_SIZE - (next_frame-frame_queue)) ) { |
| akashvibhute | 3:dfc8da7ac18c | 271 | networkFlags |= FLAG_HOLD_INCOMING; |
| akashvibhute | 3:dfc8da7ac18c | 272 | radio.stopListening(); |
| akashvibhute | 3:dfc8da7ac18c | 273 | } |
| akashvibhute | 3:dfc8da7ac18c | 274 | |
| akashvibhute | 3:dfc8da7ac18c | 275 | memcpy(&frag_queue,&frame_buffer,8); |
| akashvibhute | 3:dfc8da7ac18c | 276 | memcpy(frag_queue.message_buffer,frame_buffer+sizeof(RF24NetworkHeader),message_size); |
| akashvibhute | 3:dfc8da7ac18c | 277 | |
| akashvibhute | 3:dfc8da7ac18c | 278 | //IF_SERIAL_DEBUG_FRAGMENTATION( Serial.print(F("queue first, total frags ")); Serial.println(header->reserved); ); |
| akashvibhute | 3:dfc8da7ac18c | 279 | //Store the total size of the stored frame in message_size |
| akashvibhute | 3:dfc8da7ac18c | 280 | frag_queue.message_size = message_size; |
| akashvibhute | 3:dfc8da7ac18c | 281 | --frag_queue.header.reserved; |
| akashvibhute | 3:dfc8da7ac18c | 282 | |
| akashvibhute | 3:dfc8da7ac18c | 283 | IF_SERIAL_DEBUG_FRAGMENTATION_L2( for(int i=0; i<frag_queue.message_size; i++) { |
| akashvibhute | 3:dfc8da7ac18c | 284 | Serial.println(frag_queue.message_buffer[i],HEX); |
| akashvibhute | 3:dfc8da7ac18c | 285 | } ); |
| akashvibhute | 3:dfc8da7ac18c | 286 | |
| akashvibhute | 2:a5f8e04bd02b | 287 | return true; |
| akashvibhute | 3:dfc8da7ac18c | 288 | |
| akashvibhute | 3:dfc8da7ac18c | 289 | } else // NETWORK_MORE_FRAGMENTS |
| akashvibhute | 3:dfc8da7ac18c | 290 | if(header->type == NETWORK_LAST_FRAGMENT || header->type == NETWORK_MORE_FRAGMENTS || header->type == NETWORK_MORE_FRAGMENTS_NACK) { |
| akashvibhute | 2:a5f8e04bd02b | 291 | |
| akashvibhute | 3:dfc8da7ac18c | 292 | if(frag_queue.message_size + message_size > MAX_PAYLOAD_SIZE) { |
| akashvibhute | 3:dfc8da7ac18c | 293 | #if defined (SERIAL_DEBUG_FRAGMENTATION) || defined (SERIAL_DEBUG_MINIMAL) |
| akashvibhute | 3:dfc8da7ac18c | 294 | Serial.print(F("Drop frag ")); |
| akashvibhute | 3:dfc8da7ac18c | 295 | Serial.print(header->reserved); |
| akashvibhute | 3:dfc8da7ac18c | 296 | Serial.println(F(" Size exceeds max")); |
| akashvibhute | 3:dfc8da7ac18c | 297 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 298 | frag_queue.header.reserved=0; |
| akashvibhute | 3:dfc8da7ac18c | 299 | return false; |
| akashvibhute | 3:dfc8da7ac18c | 300 | } |
| akashvibhute | 3:dfc8da7ac18c | 301 | if( frag_queue.header.reserved == 0 || (header->type != NETWORK_LAST_FRAGMENT && header->reserved != frag_queue.header.reserved ) || frag_queue.header.id != header->id ) { |
| akashvibhute | 3:dfc8da7ac18c | 302 | #if defined (SERIAL_DEBUG_FRAGMENTATION) || defined (SERIAL_DEBUG_MINIMAL) |
| akashvibhute | 3:dfc8da7ac18c | 303 | Serial.print(F("Drop frag ")); |
| akashvibhute | 3:dfc8da7ac18c | 304 | Serial.print(header->reserved); |
| akashvibhute | 3:dfc8da7ac18c | 305 | //Serial.print(F(" header id ")); Serial.print(header->id); |
| akashvibhute | 3:dfc8da7ac18c | 306 | Serial.println(F(" Out of order ")); |
| akashvibhute | 3:dfc8da7ac18c | 307 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 308 | return false; |
| akashvibhute | 3:dfc8da7ac18c | 309 | } |
| akashvibhute | 3:dfc8da7ac18c | 310 | |
| akashvibhute | 3:dfc8da7ac18c | 311 | memcpy(frag_queue.message_buffer+frag_queue.message_size,frame_buffer+sizeof(RF24NetworkHeader),message_size); |
| akashvibhute | 3:dfc8da7ac18c | 312 | frag_queue.message_size += message_size; |
| akashvibhute | 3:dfc8da7ac18c | 313 | |
| akashvibhute | 3:dfc8da7ac18c | 314 | if(header->type != NETWORK_LAST_FRAGMENT) { |
| akashvibhute | 3:dfc8da7ac18c | 315 | --frag_queue.header.reserved; |
| akashvibhute | 3:dfc8da7ac18c | 316 | return true; |
| akashvibhute | 3:dfc8da7ac18c | 317 | } |
| akashvibhute | 3:dfc8da7ac18c | 318 | frag_queue.header.reserved = 0; |
| akashvibhute | 3:dfc8da7ac18c | 319 | frag_queue.header.type = header->reserved; |
| akashvibhute | 2:a5f8e04bd02b | 320 | |
| akashvibhute | 3:dfc8da7ac18c | 321 | IF_SERIAL_DEBUG_FRAGMENTATION( printf(PSTR("fq 3: %d\n"),frag_queue.message_size); ); |
| akashvibhute | 3:dfc8da7ac18c | 322 | IF_SERIAL_DEBUG_FRAGMENTATION_L2(for(int i=0; i< frag_queue.message_size; i++) { |
| akashvibhute | 3:dfc8da7ac18c | 323 | Serial.println(frag_queue.message_buffer[i],HEX); |
| akashvibhute | 3:dfc8da7ac18c | 324 | } ); |
| akashvibhute | 3:dfc8da7ac18c | 325 | |
| akashvibhute | 3:dfc8da7ac18c | 326 | //Frame assembly complete, copy to main buffer if OK |
| akashvibhute | 3:dfc8da7ac18c | 327 | if(frag_queue.header.type == EXTERNAL_DATA_TYPE) { |
| akashvibhute | 3:dfc8da7ac18c | 328 | return 2; |
| akashvibhute | 3:dfc8da7ac18c | 329 | } |
| akashvibhute | 3:dfc8da7ac18c | 330 | #if defined (DISABLE_USER_PAYLOADS) |
| akashvibhute | 3:dfc8da7ac18c | 331 | return 0; |
| akashvibhute | 3:dfc8da7ac18c | 332 | #endif |
| akashvibhute | 0:c3db0798d9aa | 333 | |
| akashvibhute | 3:dfc8da7ac18c | 334 | if(MAX_PAYLOAD_SIZE - (next_frame-frame_queue) >= frag_queue.message_size) { |
| akashvibhute | 3:dfc8da7ac18c | 335 | memcpy(next_frame,&frag_queue,10); |
| akashvibhute | 3:dfc8da7ac18c | 336 | memcpy(next_frame+10,frag_queue.message_buffer,frag_queue.message_size); |
| akashvibhute | 3:dfc8da7ac18c | 337 | next_frame += (10+frag_queue.message_size); |
| akashvibhute | 3:dfc8da7ac18c | 338 | IF_SERIAL_DEBUG_FRAGMENTATION( printf(PSTR("enq size %d\n"),frag_queue.message_size); ); |
| akashvibhute | 3:dfc8da7ac18c | 339 | return true; |
| akashvibhute | 3:dfc8da7ac18c | 340 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 341 | radio.stopListening(); |
| akashvibhute | 3:dfc8da7ac18c | 342 | networkFlags |= FLAG_HOLD_INCOMING; |
| akashvibhute | 3:dfc8da7ac18c | 343 | } |
| akashvibhute | 3:dfc8da7ac18c | 344 | IF_SERIAL_DEBUG_FRAGMENTATION( printf(PSTR("Drop frag payload, queue full\n")); ); |
| akashvibhute | 3:dfc8da7ac18c | 345 | return false; |
| akashvibhute | 3:dfc8da7ac18c | 346 | }//If more or last fragments |
| akashvibhute | 3:dfc8da7ac18c | 347 | |
| akashvibhute | 3:dfc8da7ac18c | 348 | } else //else is not a fragment |
| akashvibhute | 3:dfc8da7ac18c | 349 | #endif // End fragmentation enabled |
| akashvibhute | 3:dfc8da7ac18c | 350 | |
| akashvibhute | 3:dfc8da7ac18c | 351 | // Copy the current frame into the frame queue |
| akashvibhute | 2:a5f8e04bd02b | 352 | |
| akashvibhute | 2:a5f8e04bd02b | 353 | #if !defined( DISABLE_FRAGMENTATION ) |
| akashvibhute | 0:c3db0798d9aa | 354 | |
| akashvibhute | 3:dfc8da7ac18c | 355 | if(header->type == EXTERNAL_DATA_TYPE) { |
| akashvibhute | 3:dfc8da7ac18c | 356 | memcpy(&frag_queue,&frame_buffer,8); |
| akashvibhute | 3:dfc8da7ac18c | 357 | frag_queue.message_buffer = frame_buffer+sizeof(RF24NetworkHeader); |
| akashvibhute | 3:dfc8da7ac18c | 358 | frag_queue.message_size = message_size; |
| akashvibhute | 3:dfc8da7ac18c | 359 | return 2; |
| akashvibhute | 3:dfc8da7ac18c | 360 | } |
| akashvibhute | 3:dfc8da7ac18c | 361 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 362 | #if defined (DISABLE_USER_PAYLOADS) |
| akashvibhute | 2:a5f8e04bd02b | 363 | return 0; |
| akashvibhute | 3:dfc8da7ac18c | 364 | } |
| akashvibhute | 2:a5f8e04bd02b | 365 | #else |
| akashvibhute | 3:dfc8da7ac18c | 366 | if(message_size + (next_frame-frame_queue) <= MAIN_BUFFER_SIZE) |
| akashvibhute | 3:dfc8da7ac18c | 367 | { |
| akashvibhute | 3:dfc8da7ac18c | 368 | memcpy(next_frame,&frame_buffer,8); |
| akashvibhute | 3:dfc8da7ac18c | 369 | RF24NetworkFrame *f = (RF24NetworkFrame*)next_frame; |
| akashvibhute | 3:dfc8da7ac18c | 370 | f->message_size = message_size; |
| akashvibhute | 3:dfc8da7ac18c | 371 | memcpy(next_frame+10,frame_buffer+sizeof(RF24NetworkHeader),message_size); |
| akashvibhute | 2:a5f8e04bd02b | 372 | |
| akashvibhute | 3:dfc8da7ac18c | 373 | IF_SERIAL_DEBUG_FRAGMENTATION( for(int i=0; i<message_size; i++) { |
| akashvibhute | 3:dfc8da7ac18c | 374 | Serial.print(next_frame[i],HEX); |
| akashvibhute | 3:dfc8da7ac18c | 375 | Serial.print(" : "); |
| akashvibhute | 3:dfc8da7ac18c | 376 | } |
| akashvibhute | 3:dfc8da7ac18c | 377 | Serial.println(""); ); |
| akashvibhute | 3:dfc8da7ac18c | 378 | |
| akashvibhute | 3:dfc8da7ac18c | 379 | next_frame += (message_size + 10); |
| akashvibhute | 3:dfc8da7ac18c | 380 | IF_SERIAL_DEBUG_FRAGMENTATION( Serial.print("Enq "); Serial.println(next_frame-frame_queue); );//printf_P(PSTR("enq %d\n"),next_frame-frame_queue); ); |
| akashvibhute | 3:dfc8da7ac18c | 381 | |
| akashvibhute | 3:dfc8da7ac18c | 382 | result = true; |
| akashvibhute | 3:dfc8da7ac18c | 383 | } else |
| akashvibhute | 3:dfc8da7ac18c | 384 | { |
| akashvibhute | 3:dfc8da7ac18c | 385 | result = false; |
| akashvibhute | 3:dfc8da7ac18c | 386 | IF_SERIAL_DEBUG(printf_P(PSTR("NET **Drop Payload** Buffer Full"))); |
| akashvibhute | 3:dfc8da7ac18c | 387 | } |
| akashvibhute | 3:dfc8da7ac18c | 388 | return result; |
| akashvibhute | 0:c3db0798d9aa | 389 | } |
| akashvibhute | 2:a5f8e04bd02b | 390 | #endif //USER_PAYLOADS_ENABLED |
| akashvibhute | 2:a5f8e04bd02b | 391 | |
| akashvibhute | 0:c3db0798d9aa | 392 | |
| akashvibhute | 0:c3db0798d9aa | 393 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 394 | |
| akashvibhute | 0:c3db0798d9aa | 395 | bool RF24Network::available(void) |
| akashvibhute | 0:c3db0798d9aa | 396 | { |
| akashvibhute | 3:dfc8da7ac18c | 397 | // Are there frames on the queue for us? |
| akashvibhute | 3:dfc8da7ac18c | 398 | return (next_frame > frame_queue); |
| akashvibhute | 2:a5f8e04bd02b | 399 | |
| akashvibhute | 0:c3db0798d9aa | 400 | } |
| akashvibhute | 0:c3db0798d9aa | 401 | |
| akashvibhute | 0:c3db0798d9aa | 402 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 403 | |
| akashvibhute | 2:a5f8e04bd02b | 404 | uint16_t RF24Network::parent() const |
| akashvibhute | 0:c3db0798d9aa | 405 | { |
| akashvibhute | 3:dfc8da7ac18c | 406 | if ( node_address == 0 ) |
| akashvibhute | 3:dfc8da7ac18c | 407 | return -1; |
| akashvibhute | 3:dfc8da7ac18c | 408 | else |
| akashvibhute | 3:dfc8da7ac18c | 409 | return parent_node; |
| akashvibhute | 2:a5f8e04bd02b | 410 | } |
| akashvibhute | 0:c3db0798d9aa | 411 | |
| akashvibhute | 2:a5f8e04bd02b | 412 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 413 | /*uint8_t RF24Network::peekData(){ |
| akashvibhute | 3:dfc8da7ac18c | 414 | |
| akashvibhute | 2:a5f8e04bd02b | 415 | return frame_queue[0]; |
| akashvibhute | 2:a5f8e04bd02b | 416 | }*/ |
| akashvibhute | 2:a5f8e04bd02b | 417 | |
| akashvibhute | 2:a5f8e04bd02b | 418 | uint16_t RF24Network::peek(RF24NetworkHeader& header) |
| akashvibhute | 2:a5f8e04bd02b | 419 | { |
| akashvibhute | 3:dfc8da7ac18c | 420 | if ( available() ) { |
| akashvibhute | 3:dfc8da7ac18c | 421 | RF24NetworkFrame *frame = (RF24NetworkFrame*)(frame_queue); |
| akashvibhute | 3:dfc8da7ac18c | 422 | memcpy(&header,&frame->header,sizeof(RF24NetworkHeader)); |
| akashvibhute | 3:dfc8da7ac18c | 423 | return frame->message_size; |
| akashvibhute | 2:a5f8e04bd02b | 424 | |
| akashvibhute | 3:dfc8da7ac18c | 425 | } |
| akashvibhute | 3:dfc8da7ac18c | 426 | return 0; |
| akashvibhute | 2:a5f8e04bd02b | 427 | } |
| akashvibhute | 2:a5f8e04bd02b | 428 | |
| akashvibhute | 2:a5f8e04bd02b | 429 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 430 | |
| akashvibhute | 2:a5f8e04bd02b | 431 | uint16_t RF24Network::read(RF24NetworkHeader& header,void* message, uint16_t maxlen) |
| akashvibhute | 2:a5f8e04bd02b | 432 | { |
| akashvibhute | 3:dfc8da7ac18c | 433 | uint16_t bufsize = 0; |
| akashvibhute | 3:dfc8da7ac18c | 434 | |
| akashvibhute | 3:dfc8da7ac18c | 435 | if ( available() ) { |
| akashvibhute | 2:a5f8e04bd02b | 436 | |
| akashvibhute | 3:dfc8da7ac18c | 437 | memcpy(&header,frame_queue,8); |
| akashvibhute | 3:dfc8da7ac18c | 438 | RF24NetworkFrame *f = (RF24NetworkFrame*)frame_queue; |
| akashvibhute | 3:dfc8da7ac18c | 439 | bufsize = f->message_size; |
| akashvibhute | 3:dfc8da7ac18c | 440 | |
| akashvibhute | 3:dfc8da7ac18c | 441 | if (maxlen > 0) { |
| akashvibhute | 3:dfc8da7ac18c | 442 | maxlen = min(maxlen,bufsize); |
| akashvibhute | 3:dfc8da7ac18c | 443 | memcpy(message,frame_queue+10,maxlen); |
| pietor | 6:80195a45b25c | 444 | IF_SERIAL_DEBUG(printf(": NET message size %d\n",bufsize);); |
| akashvibhute | 2:a5f8e04bd02b | 445 | |
| pietor | 6:80195a45b25c | 446 | IF_SERIAL_DEBUG( uint16_t len = maxlen; printf_P(PSTR(": NET r message ")); const uint8_t* charPtr = reinterpret_cast<const uint8_t*>(message); while(len--) { |
| akashvibhute | 3:dfc8da7ac18c | 447 | printf("%02x ",charPtr[len]); |
| akashvibhute | 3:dfc8da7ac18c | 448 | } |
| akashvibhute | 3:dfc8da7ac18c | 449 | printf_P(PSTR("\n\r") ) ); |
| akashvibhute | 2:a5f8e04bd02b | 450 | |
| akashvibhute | 3:dfc8da7ac18c | 451 | } |
| akashvibhute | 3:dfc8da7ac18c | 452 | memmove(frame_queue,frame_queue+bufsize+10,sizeof(frame_queue)- bufsize); |
| akashvibhute | 3:dfc8da7ac18c | 453 | next_frame-=bufsize+10; |
| akashvibhute | 2:a5f8e04bd02b | 454 | |
| pietor | 6:80195a45b25c | 455 | IF_SERIAL_DEBUG(printf_P(PSTR(": NET Received %s\n\r"),header.toString())); |
| akashvibhute | 2:a5f8e04bd02b | 456 | } |
| akashvibhute | 0:c3db0798d9aa | 457 | |
| akashvibhute | 3:dfc8da7ac18c | 458 | return bufsize; |
| akashvibhute | 0:c3db0798d9aa | 459 | } |
| akashvibhute | 0:c3db0798d9aa | 460 | |
| akashvibhute | 2:a5f8e04bd02b | 461 | |
| akashvibhute | 2:a5f8e04bd02b | 462 | #if defined RF24NetworkMulticast |
| akashvibhute | 2:a5f8e04bd02b | 463 | /******************************************************************/ |
| akashvibhute | 3:dfc8da7ac18c | 464 | bool RF24Network::multicast(RF24NetworkHeader& header,const void* message, uint16_t len, uint8_t level) |
| akashvibhute | 3:dfc8da7ac18c | 465 | { |
| akashvibhute | 2:a5f8e04bd02b | 466 | // Fill out the header |
| akashvibhute | 3:dfc8da7ac18c | 467 | header.to_node = 0100; |
| akashvibhute | 3:dfc8da7ac18c | 468 | header.from_node = node_address; |
| akashvibhute | 3:dfc8da7ac18c | 469 | return write(header, message, len, levelToAddress(level)); |
| akashvibhute | 2:a5f8e04bd02b | 470 | } |
| akashvibhute | 2:a5f8e04bd02b | 471 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 472 | |
| akashvibhute | 2:a5f8e04bd02b | 473 | /******************************************************************/ |
| akashvibhute | 3:dfc8da7ac18c | 474 | bool RF24Network::write(RF24NetworkHeader& header,const void* message, uint16_t len) |
| akashvibhute | 3:dfc8da7ac18c | 475 | { |
| akashvibhute | 2:a5f8e04bd02b | 476 | return write(header,message,len,070); |
| akashvibhute | 2:a5f8e04bd02b | 477 | } |
| akashvibhute | 2:a5f8e04bd02b | 478 | /******************************************************************/ |
| akashvibhute | 3:dfc8da7ac18c | 479 | bool RF24Network::write(RF24NetworkHeader& header,const void* message, uint16_t len, uint16_t writeDirect) |
| akashvibhute | 3:dfc8da7ac18c | 480 | { |
| akashvibhute | 3:dfc8da7ac18c | 481 | |
| akashvibhute | 2:a5f8e04bd02b | 482 | //Allows time for requests (RF24Mesh) to get through between failed writes on busy nodes |
| akashvibhute | 3:dfc8da7ac18c | 483 | while(rf24netTimer.read_ms()-txTime < 25) { |
| akashvibhute | 3:dfc8da7ac18c | 484 | if(update() > 127) { |
| akashvibhute | 3:dfc8da7ac18c | 485 | break; |
| akashvibhute | 3:dfc8da7ac18c | 486 | } |
| akashvibhute | 3:dfc8da7ac18c | 487 | } |
| akashvibhute | 2:a5f8e04bd02b | 488 | wait_us(200); |
| akashvibhute | 2:a5f8e04bd02b | 489 | |
| akashvibhute | 2:a5f8e04bd02b | 490 | #if defined (DISABLE_FRAGMENTATION) |
| akashvibhute | 2:a5f8e04bd02b | 491 | frame_size = rf24_min(len+sizeof(RF24NetworkHeader),MAX_FRAME_SIZE); |
| akashvibhute | 2:a5f8e04bd02b | 492 | return _write(header,message,rf24_min(len,max_frame_payload_size),writeDirect); |
| akashvibhute | 3:dfc8da7ac18c | 493 | #else |
| akashvibhute | 3:dfc8da7ac18c | 494 | if(len <= max_frame_payload_size) { |
| akashvibhute | 3:dfc8da7ac18c | 495 | //Normal Write (Un-Fragmented) |
| akashvibhute | 3:dfc8da7ac18c | 496 | frame_size = len + sizeof(RF24NetworkHeader); |
| akashvibhute | 3:dfc8da7ac18c | 497 | if(_write(header,message,len,writeDirect)) { |
| akashvibhute | 3:dfc8da7ac18c | 498 | return 1; |
| akashvibhute | 3:dfc8da7ac18c | 499 | } |
| akashvibhute | 3:dfc8da7ac18c | 500 | txTime = rf24netTimer.read_ms(); |
| akashvibhute | 3:dfc8da7ac18c | 501 | return 0; |
| akashvibhute | 2:a5f8e04bd02b | 502 | } |
| akashvibhute | 3:dfc8da7ac18c | 503 | //Check payload size |
| akashvibhute | 3:dfc8da7ac18c | 504 | if (len > MAX_PAYLOAD_SIZE) { |
| pietor | 6:80195a45b25c | 505 | IF_SERIAL_DEBUG(printf("%u: NET write message failed. Given 'len' %d is bigger than the MAX Payload size %i\n\r",len,MAX_PAYLOAD_SIZE);); |
| akashvibhute | 3:dfc8da7ac18c | 506 | return false; |
| akashvibhute | 3:dfc8da7ac18c | 507 | } |
| akashvibhute | 2:a5f8e04bd02b | 508 | |
| akashvibhute | 3:dfc8da7ac18c | 509 | //Divide the message payload into chunks of max_frame_payload_size |
| akashvibhute | 3:dfc8da7ac18c | 510 | uint8_t fragment_id = (len % max_frame_payload_size != 0) + ((len ) / max_frame_payload_size); //the number of fragments to send = ceil(len/max_frame_payload_size) |
| akashvibhute | 2:a5f8e04bd02b | 511 | |
| akashvibhute | 3:dfc8da7ac18c | 512 | uint8_t msgCount = 0; |
| akashvibhute | 2:a5f8e04bd02b | 513 | |
| akashvibhute | 3:dfc8da7ac18c | 514 | IF_SERIAL_DEBUG_FRAGMENTATION(printf("%lu: FRG Total message fragments %d\n\r",millis(),fragment_id);); |
| akashvibhute | 2:a5f8e04bd02b | 515 | |
| akashvibhute | 3:dfc8da7ac18c | 516 | if(header.to_node != 0100) { |
| akashvibhute | 3:dfc8da7ac18c | 517 | networkFlags |= FLAG_FAST_FRAG; |
| akashvibhute | 3:dfc8da7ac18c | 518 | #if !defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 519 | radio.stopListening(); |
| akashvibhute | 3:dfc8da7ac18c | 520 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 521 | } |
| akashvibhute | 2:a5f8e04bd02b | 522 | |
| akashvibhute | 3:dfc8da7ac18c | 523 | uint8_t retriesPerFrag = 0; |
| akashvibhute | 3:dfc8da7ac18c | 524 | uint8_t type = header.type; |
| akashvibhute | 3:dfc8da7ac18c | 525 | |
| akashvibhute | 3:dfc8da7ac18c | 526 | while (fragment_id > 0) { |
| akashvibhute | 3:dfc8da7ac18c | 527 | |
| akashvibhute | 3:dfc8da7ac18c | 528 | //Copy and fill out the header |
| akashvibhute | 3:dfc8da7ac18c | 529 | //RF24NetworkHeader fragmentHeader = header; |
| akashvibhute | 3:dfc8da7ac18c | 530 | header.reserved = fragment_id; |
| akashvibhute | 2:a5f8e04bd02b | 531 | |
| akashvibhute | 3:dfc8da7ac18c | 532 | if (fragment_id == 1) { |
| akashvibhute | 3:dfc8da7ac18c | 533 | header.type = NETWORK_LAST_FRAGMENT; //Set the last fragment flag to indicate the last fragment |
| akashvibhute | 3:dfc8da7ac18c | 534 | header.reserved = type; //The reserved field is used to transmit the header type |
| akashvibhute | 3:dfc8da7ac18c | 535 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 536 | if (msgCount == 0) { |
| akashvibhute | 3:dfc8da7ac18c | 537 | header.type = NETWORK_FIRST_FRAGMENT; |
| akashvibhute | 3:dfc8da7ac18c | 538 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 539 | header.type = NETWORK_MORE_FRAGMENTS; //Set the more fragments flag to indicate a fragmented frame |
| akashvibhute | 3:dfc8da7ac18c | 540 | } |
| akashvibhute | 3:dfc8da7ac18c | 541 | } |
| akashvibhute | 3:dfc8da7ac18c | 542 | |
| akashvibhute | 3:dfc8da7ac18c | 543 | uint16_t offset = msgCount*max_frame_payload_size; |
| akashvibhute | 3:dfc8da7ac18c | 544 | uint16_t fragmentLen = rf24_min((uint16_t)(len-offset),max_frame_payload_size); |
| akashvibhute | 3:dfc8da7ac18c | 545 | |
| akashvibhute | 3:dfc8da7ac18c | 546 | //Try to send the payload chunk with the copied header |
| akashvibhute | 3:dfc8da7ac18c | 547 | frame_size = sizeof(RF24NetworkHeader)+fragmentLen; |
| akashvibhute | 3:dfc8da7ac18c | 548 | bool ok = _write(header,((char *)message)+offset,fragmentLen,writeDirect); |
| akashvibhute | 3:dfc8da7ac18c | 549 | |
| akashvibhute | 3:dfc8da7ac18c | 550 | if (!ok) { |
| akashvibhute | 3:dfc8da7ac18c | 551 | wait_ms(2); |
| akashvibhute | 3:dfc8da7ac18c | 552 | ++retriesPerFrag; |
| akashvibhute | 2:a5f8e04bd02b | 553 | |
| akashvibhute | 3:dfc8da7ac18c | 554 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 555 | retriesPerFrag = 0; |
| akashvibhute | 3:dfc8da7ac18c | 556 | fragment_id--; |
| akashvibhute | 3:dfc8da7ac18c | 557 | msgCount++; |
| akashvibhute | 3:dfc8da7ac18c | 558 | } |
| akashvibhute | 3:dfc8da7ac18c | 559 | |
| akashvibhute | 3:dfc8da7ac18c | 560 | if(writeDirect != 070) { |
| akashvibhute | 3:dfc8da7ac18c | 561 | wait_ms(2); //Delay 2ms between sending multicast payloads |
| akashvibhute | 3:dfc8da7ac18c | 562 | } |
| akashvibhute | 3:dfc8da7ac18c | 563 | |
| akashvibhute | 3:dfc8da7ac18c | 564 | if (!ok && retriesPerFrag >= 3) { |
| akashvibhute | 3:dfc8da7ac18c | 565 | IF_SERIAL_DEBUG_FRAGMENTATION(printf("%lu: FRG TX with fragmentID '%d' failed after %d fragments. Abort.\n\r",millis(),fragment_id,msgCount);); |
| akashvibhute | 3:dfc8da7ac18c | 566 | break; |
| akashvibhute | 3:dfc8da7ac18c | 567 | } |
| akashvibhute | 3:dfc8da7ac18c | 568 | |
| akashvibhute | 3:dfc8da7ac18c | 569 | //Message was successful sent |
| akashvibhute | 3:dfc8da7ac18c | 570 | #if defined SERIAL_DEBUG_FRAGMENTATION_L2 |
| akashvibhute | 3:dfc8da7ac18c | 571 | printf("%lu: FRG message transmission with fragmentID '%d' sucessfull.\n\r",millis(),fragment_id); |
| akashvibhute | 3:dfc8da7ac18c | 572 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 573 | |
| akashvibhute | 3:dfc8da7ac18c | 574 | } |
| akashvibhute | 3:dfc8da7ac18c | 575 | |
| akashvibhute | 3:dfc8da7ac18c | 576 | #if !defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 577 | if(networkFlags & FLAG_FAST_FRAG) { |
| akashvibhute | 3:dfc8da7ac18c | 578 | radio.startListening(); |
| akashvibhute | 3:dfc8da7ac18c | 579 | } |
| akashvibhute | 3:dfc8da7ac18c | 580 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 581 | networkFlags &= ~FLAG_FAST_FRAG |
| akashvibhute | 3:dfc8da7ac18c | 582 | //int frag_delay = uint8_t(len/48); |
| akashvibhute | 3:dfc8da7ac18c | 583 | //delay( rf24_min(len/48,20)); |
| akashvibhute | 3:dfc8da7ac18c | 584 | |
| akashvibhute | 3:dfc8da7ac18c | 585 | //Return true if all the chunks where sent successfully |
| akashvibhute | 3:dfc8da7ac18c | 586 | |
| akashvibhute | 3:dfc8da7ac18c | 587 | IF_SERIAL_DEBUG_FRAGMENTATION(printf("%u: FRG total message fragments sent %i. \n",millis(),msgCount); ); |
| akashvibhute | 3:dfc8da7ac18c | 588 | if(fragment_id > 0) { |
| akashvibhute | 3:dfc8da7ac18c | 589 | txTime = rf24netTimer.read_ms(); |
| akashvibhute | 3:dfc8da7ac18c | 590 | return false; |
| akashvibhute | 3:dfc8da7ac18c | 591 | } |
| akashvibhute | 3:dfc8da7ac18c | 592 | return true; |
| akashvibhute | 3:dfc8da7ac18c | 593 | |
| akashvibhute | 2:a5f8e04bd02b | 594 | #endif //Fragmentation enabled |
| akashvibhute | 2:a5f8e04bd02b | 595 | } |
| akashvibhute | 0:c3db0798d9aa | 596 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 597 | |
| akashvibhute | 2:a5f8e04bd02b | 598 | bool RF24Network::_write(RF24NetworkHeader& header,const void* message, uint16_t len, uint16_t writeDirect) |
| akashvibhute | 0:c3db0798d9aa | 599 | { |
| akashvibhute | 3:dfc8da7ac18c | 600 | // Fill out the header |
| akashvibhute | 3:dfc8da7ac18c | 601 | header.from_node = node_address; |
| akashvibhute | 2:a5f8e04bd02b | 602 | |
| akashvibhute | 3:dfc8da7ac18c | 603 | // Build the full frame to send |
| akashvibhute | 3:dfc8da7ac18c | 604 | memcpy(frame_buffer,&header,sizeof(RF24NetworkHeader)); |
| akashvibhute | 3:dfc8da7ac18c | 605 | |
| pietor | 6:80195a45b25c | 606 | IF_SERIAL_DEBUG(printf_P(PSTR("NET Sending %s\n\r"),header.toString())); |
| akashvibhute | 2:a5f8e04bd02b | 607 | |
| akashvibhute | 3:dfc8da7ac18c | 608 | if (len) { |
| akashvibhute | 3:dfc8da7ac18c | 609 | |
| akashvibhute | 3:dfc8da7ac18c | 610 | memcpy(frame_buffer + sizeof(RF24NetworkHeader),message,len); |
| akashvibhute | 0:c3db0798d9aa | 611 | |
| pietor | 6:80195a45b25c | 612 | IF_SERIAL_DEBUG(uint16_t tmpLen = len; printf_P(PSTR("NET message ")); const uint8_t* charPtr = reinterpret_cast<const uint8_t*>(message); while(tmpLen--) { |
| akashvibhute | 3:dfc8da7ac18c | 613 | printf("%02x ",charPtr[tmpLen]); |
| akashvibhute | 3:dfc8da7ac18c | 614 | } |
| akashvibhute | 3:dfc8da7ac18c | 615 | printf_P(PSTR("\n\r") ) ); |
| akashvibhute | 2:a5f8e04bd02b | 616 | |
| akashvibhute | 3:dfc8da7ac18c | 617 | } |
| akashvibhute | 0:c3db0798d9aa | 618 | |
| akashvibhute | 3:dfc8da7ac18c | 619 | // If the user is trying to send it to himself |
| akashvibhute | 3:dfc8da7ac18c | 620 | /*if ( header.to_node == node_address ){ |
| akashvibhute | 3:dfc8da7ac18c | 621 | #if defined (RF24_LINUX) |
| akashvibhute | 3:dfc8da7ac18c | 622 | RF24NetworkFrame frame = RF24NetworkFrame(header,message,rf24_min(MAX_FRAME_SIZE-sizeof(RF24NetworkHeader),len)); |
| akashvibhute | 3:dfc8da7ac18c | 623 | #else |
| akashvibhute | 3:dfc8da7ac18c | 624 | RF24NetworkFrame frame(header,len); |
| akashvibhute | 3:dfc8da7ac18c | 625 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 626 | // Just queue it in the received queue |
| akashvibhute | 3:dfc8da7ac18c | 627 | return enqueue(frame); |
| akashvibhute | 3:dfc8da7ac18c | 628 | }*/ |
| akashvibhute | 3:dfc8da7ac18c | 629 | // Otherwise send it out over the air |
| akashvibhute | 3:dfc8da7ac18c | 630 | |
| akashvibhute | 3:dfc8da7ac18c | 631 | |
| akashvibhute | 3:dfc8da7ac18c | 632 | if(writeDirect != 070) { |
| akashvibhute | 2:a5f8e04bd02b | 633 | uint8_t sendType = USER_TX_TO_LOGICAL_ADDRESS; // Payload is multicast to the first node, and routed normally to the next |
| akashvibhute | 3:dfc8da7ac18c | 634 | |
| akashvibhute | 3:dfc8da7ac18c | 635 | if(header.to_node == 0100) { |
| akashvibhute | 3:dfc8da7ac18c | 636 | sendType = USER_TX_MULTICAST; |
| akashvibhute | 2:a5f8e04bd02b | 637 | } |
| akashvibhute | 3:dfc8da7ac18c | 638 | if(header.to_node == writeDirect) { |
| akashvibhute | 3:dfc8da7ac18c | 639 | sendType = USER_TX_TO_PHYSICAL_ADDRESS; // Payload is multicast to the first node, which is the recipient |
| akashvibhute | 2:a5f8e04bd02b | 640 | } |
| akashvibhute | 3:dfc8da7ac18c | 641 | return write(writeDirect,sendType); |
| akashvibhute | 2:a5f8e04bd02b | 642 | } |
| akashvibhute | 2:a5f8e04bd02b | 643 | return write(header.to_node,TX_NORMAL); |
| akashvibhute | 3:dfc8da7ac18c | 644 | |
| akashvibhute | 0:c3db0798d9aa | 645 | } |
| akashvibhute | 0:c3db0798d9aa | 646 | |
| akashvibhute | 0:c3db0798d9aa | 647 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 648 | |
| akashvibhute | 2:a5f8e04bd02b | 649 | bool RF24Network::write(uint16_t to_node, uint8_t directTo) // Direct To: 0 = First Payload, standard routing, 1=routed payload, 2=directRoute to host, 3=directRoute to Route |
| akashvibhute | 0:c3db0798d9aa | 650 | { |
| akashvibhute | 3:dfc8da7ac18c | 651 | bool ok = false; |
| akashvibhute | 3:dfc8da7ac18c | 652 | bool isAckType = false; |
| akashvibhute | 3:dfc8da7ac18c | 653 | if(frame_buffer[6] > 64 && frame_buffer[6] < 192 ) { |
| akashvibhute | 3:dfc8da7ac18c | 654 | isAckType=true; |
| akashvibhute | 3:dfc8da7ac18c | 655 | } |
| akashvibhute | 3:dfc8da7ac18c | 656 | |
| akashvibhute | 3:dfc8da7ac18c | 657 | /*if( ( (frame_buffer[7] % 2) && frame_buffer[6] == NETWORK_MORE_FRAGMENTS) ){ |
| akashvibhute | 3:dfc8da7ac18c | 658 | isAckType = 0; |
| akashvibhute | 3:dfc8da7ac18c | 659 | }*/ |
| akashvibhute | 3:dfc8da7ac18c | 660 | |
| akashvibhute | 3:dfc8da7ac18c | 661 | // Throw it away if it's not a valid address |
| akashvibhute | 3:dfc8da7ac18c | 662 | if ( !is_valid_address(to_node) ) |
| akashvibhute | 3:dfc8da7ac18c | 663 | return false; |
| akashvibhute | 2:a5f8e04bd02b | 664 | |
| akashvibhute | 3:dfc8da7ac18c | 665 | //Load info into our conversion structure, and get the converted address info |
| akashvibhute | 3:dfc8da7ac18c | 666 | logicalToPhysicalStruct conversion = { to_node,directTo,0}; |
| akashvibhute | 3:dfc8da7ac18c | 667 | logicalToPhysicalAddress(&conversion); |
| akashvibhute | 3:dfc8da7ac18c | 668 | |
| akashvibhute | 3:dfc8da7ac18c | 669 | |
| pietor | 6:80195a45b25c | 670 | IF_SERIAL_DEBUG(printf_P(PSTR("MAC Sending to 0%o via 0%o on pipe %x\n\r"),to_node,conversion.send_node,conversion.send_pipe)); |
| akashvibhute | 2:a5f8e04bd02b | 671 | |
| akashvibhute | 3:dfc8da7ac18c | 672 | /**Write it*/ |
| akashvibhute | 3:dfc8da7ac18c | 673 | ok=write_to_pipe(conversion.send_node, conversion.send_pipe, conversion.multicast); |
| akashvibhute | 0:c3db0798d9aa | 674 | |
| akashvibhute | 3:dfc8da7ac18c | 675 | |
| akashvibhute | 3:dfc8da7ac18c | 676 | if(!ok) { |
| akashvibhute | 3:dfc8da7ac18c | 677 | IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%lu: MAC Send fail to 0%o via 0%o on pipe %x\n\r"),millis(),to_node,conversion.send_node,conversion.send_pipe);); |
| akashvibhute | 2:a5f8e04bd02b | 678 | } |
| akashvibhute | 2:a5f8e04bd02b | 679 | |
| akashvibhute | 3:dfc8da7ac18c | 680 | |
| akashvibhute | 3:dfc8da7ac18c | 681 | if( directTo == TX_ROUTED && ok && conversion.send_node == to_node && isAckType) { |
| akashvibhute | 3:dfc8da7ac18c | 682 | |
| akashvibhute | 3:dfc8da7ac18c | 683 | RF24NetworkHeader* header = (RF24NetworkHeader*)&frame_buffer; |
| akashvibhute | 3:dfc8da7ac18c | 684 | header->type = NETWORK_ACK; // Set the payload type to NETWORK_ACK |
| akashvibhute | 3:dfc8da7ac18c | 685 | header->to_node = header->from_node; // Change the 'to' address to the 'from' address |
| akashvibhute | 2:a5f8e04bd02b | 686 | |
| akashvibhute | 3:dfc8da7ac18c | 687 | conversion.send_node = header->from_node; |
| akashvibhute | 3:dfc8da7ac18c | 688 | conversion.send_pipe = TX_ROUTED; |
| akashvibhute | 3:dfc8da7ac18c | 689 | conversion.multicast = 0; |
| akashvibhute | 3:dfc8da7ac18c | 690 | logicalToPhysicalAddress(&conversion); |
| akashvibhute | 0:c3db0798d9aa | 691 | |
| akashvibhute | 3:dfc8da7ac18c | 692 | //Write the data using the resulting physical address |
| akashvibhute | 3:dfc8da7ac18c | 693 | frame_size = sizeof(RF24NetworkHeader); |
| akashvibhute | 3:dfc8da7ac18c | 694 | write_to_pipe(conversion.send_node, conversion.send_pipe, conversion.multicast); |
| akashvibhute | 3:dfc8da7ac18c | 695 | |
| akashvibhute | 3:dfc8da7ac18c | 696 | //dynLen=0; |
| akashvibhute | 3:dfc8da7ac18c | 697 | |
| akashvibhute | 3:dfc8da7ac18c | 698 | IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%lu MAC: Route OK to 0%o ACK sent to 0%o\n"),millis(),to_node,header->from_node); ); |
| akashvibhute | 2:a5f8e04bd02b | 699 | |
| akashvibhute | 2:a5f8e04bd02b | 700 | } |
| akashvibhute | 2:a5f8e04bd02b | 701 | |
| akashvibhute | 2:a5f8e04bd02b | 702 | |
| akashvibhute | 3:dfc8da7ac18c | 703 | if( ok && conversion.send_node != to_node && (directTo==0 || directTo==3) && isAckType) { |
| akashvibhute | 3:dfc8da7ac18c | 704 | #if !defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 705 | // Now, continue listening |
| akashvibhute | 3:dfc8da7ac18c | 706 | if(networkFlags & FLAG_FAST_FRAG) { |
| akashvibhute | 3:dfc8da7ac18c | 707 | radio.txStandBy(txTimeout); |
| akashvibhute | 3:dfc8da7ac18c | 708 | networkFlags &= ~FLAG_FAST_FRAG; |
| akashvibhute | 3:dfc8da7ac18c | 709 | } |
| akashvibhute | 3:dfc8da7ac18c | 710 | radio.startListening(); |
| akashvibhute | 3:dfc8da7ac18c | 711 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 712 | uint32_t reply_time = rf24netTimer.read_ms(); |
| akashvibhute | 0:c3db0798d9aa | 713 | |
| akashvibhute | 3:dfc8da7ac18c | 714 | while( update() != NETWORK_ACK) { |
| akashvibhute | 2:a5f8e04bd02b | 715 | wait_us(900); |
| akashvibhute | 3:dfc8da7ac18c | 716 | if(rf24netTimer.read_ms() - reply_time > routeTimeout) { |
| akashvibhute | 2:a5f8e04bd02b | 717 | |
| akashvibhute | 3:dfc8da7ac18c | 718 | IF_SERIAL_DEBUG_ROUTING( printf_P(PSTR("%lu: MAC Network ACK fail from 0%o via 0%o on pipe %x\n\r"),millis(),to_node,conversion.send_node,conversion.send_pipe); ); |
| akashvibhute | 2:a5f8e04bd02b | 719 | |
| akashvibhute | 2:a5f8e04bd02b | 720 | ok=false; |
| akashvibhute | 3:dfc8da7ac18c | 721 | break; |
| akashvibhute | 2:a5f8e04bd02b | 722 | } |
| akashvibhute | 2:a5f8e04bd02b | 723 | } |
| akashvibhute | 2:a5f8e04bd02b | 724 | } |
| akashvibhute | 3:dfc8da7ac18c | 725 | if( !(networkFlags & FLAG_FAST_FRAG) ) { |
| akashvibhute | 3:dfc8da7ac18c | 726 | #if !defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 727 | // Now, continue listening |
| akashvibhute | 3:dfc8da7ac18c | 728 | radio.startListening(); |
| akashvibhute | 3:dfc8da7ac18c | 729 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 730 | } |
| akashvibhute | 2:a5f8e04bd02b | 731 | |
| akashvibhute | 2:a5f8e04bd02b | 732 | #if defined ENABLE_NETWORK_STATS |
| akashvibhute | 3:dfc8da7ac18c | 733 | if(ok == true) { |
| akashvibhute | 3:dfc8da7ac18c | 734 | ++nOK; |
| akashvibhute | 3:dfc8da7ac18c | 735 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 736 | ++nFails; |
| akashvibhute | 3:dfc8da7ac18c | 737 | } |
| akashvibhute | 0:c3db0798d9aa | 738 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 739 | return ok; |
| akashvibhute | 0:c3db0798d9aa | 740 | } |
| akashvibhute | 0:c3db0798d9aa | 741 | |
| akashvibhute | 0:c3db0798d9aa | 742 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 743 | |
| akashvibhute | 3:dfc8da7ac18c | 744 | // Provided the to_node and directTo option, it will return the resulting node and pipe |
| akashvibhute | 3:dfc8da7ac18c | 745 | bool RF24Network::logicalToPhysicalAddress(logicalToPhysicalStruct *conversionInfo) |
| akashvibhute | 3:dfc8da7ac18c | 746 | { |
| akashvibhute | 3:dfc8da7ac18c | 747 | |
| akashvibhute | 3:dfc8da7ac18c | 748 | //Create pointers so this makes sense.. kind of |
| akashvibhute | 3:dfc8da7ac18c | 749 | //We take in the to_node(logical) now, at the end of the function, output the send_node(physical) address, etc. |
| akashvibhute | 3:dfc8da7ac18c | 750 | //back to the original memory address that held the logical information. |
| akashvibhute | 3:dfc8da7ac18c | 751 | uint16_t *to_node = &conversionInfo->send_node; |
| akashvibhute | 3:dfc8da7ac18c | 752 | uint8_t *directTo = &conversionInfo->send_pipe; |
| akashvibhute | 3:dfc8da7ac18c | 753 | bool *multicast = &conversionInfo->multicast; |
| akashvibhute | 2:a5f8e04bd02b | 754 | |
| akashvibhute | 3:dfc8da7ac18c | 755 | // Where do we send this? By default, to our parent |
| akashvibhute | 3:dfc8da7ac18c | 756 | uint16_t pre_conversion_send_node = parent_node; |
| akashvibhute | 2:a5f8e04bd02b | 757 | |
| akashvibhute | 3:dfc8da7ac18c | 758 | // On which pipe |
| akashvibhute | 3:dfc8da7ac18c | 759 | uint8_t pre_conversion_send_pipe = parent_pipe %5; |
| akashvibhute | 3:dfc8da7ac18c | 760 | |
| akashvibhute | 3:dfc8da7ac18c | 761 | if(*directTo > TX_ROUTED ) { |
| akashvibhute | 3:dfc8da7ac18c | 762 | pre_conversion_send_node = *to_node; |
| akashvibhute | 3:dfc8da7ac18c | 763 | *multicast = 1; |
| akashvibhute | 3:dfc8da7ac18c | 764 | //if(*directTo == USER_TX_MULTICAST || *directTo == USER_TX_TO_PHYSICAL_ADDRESS){ |
| akashvibhute | 2:a5f8e04bd02b | 765 | pre_conversion_send_pipe=0; |
| akashvibhute | 3:dfc8da7ac18c | 766 | //} |
| akashvibhute | 3:dfc8da7ac18c | 767 | } |
| akashvibhute | 3:dfc8da7ac18c | 768 | // If the node is a direct child, |
| akashvibhute | 3:dfc8da7ac18c | 769 | else if ( is_direct_child(*to_node) ) { |
| akashvibhute | 3:dfc8da7ac18c | 770 | // Send directly |
| akashvibhute | 3:dfc8da7ac18c | 771 | pre_conversion_send_node = *to_node; |
| akashvibhute | 3:dfc8da7ac18c | 772 | // To its listening pipe |
| akashvibhute | 3:dfc8da7ac18c | 773 | pre_conversion_send_pipe = 5; |
| akashvibhute | 3:dfc8da7ac18c | 774 | } |
| akashvibhute | 3:dfc8da7ac18c | 775 | // If the node is a child of a child |
| akashvibhute | 3:dfc8da7ac18c | 776 | // talk on our child's listening pipe, |
| akashvibhute | 3:dfc8da7ac18c | 777 | // and let the direct child relay it. |
| akashvibhute | 3:dfc8da7ac18c | 778 | else if ( is_descendant(*to_node) ) { |
| akashvibhute | 3:dfc8da7ac18c | 779 | pre_conversion_send_node = direct_child_route_to(*to_node); |
| akashvibhute | 3:dfc8da7ac18c | 780 | pre_conversion_send_pipe = 5; |
| akashvibhute | 3:dfc8da7ac18c | 781 | } |
| akashvibhute | 3:dfc8da7ac18c | 782 | |
| akashvibhute | 3:dfc8da7ac18c | 783 | *to_node = pre_conversion_send_node; |
| akashvibhute | 3:dfc8da7ac18c | 784 | *directTo = pre_conversion_send_pipe; |
| akashvibhute | 3:dfc8da7ac18c | 785 | |
| akashvibhute | 3:dfc8da7ac18c | 786 | return 1; |
| akashvibhute | 3:dfc8da7ac18c | 787 | |
| akashvibhute | 2:a5f8e04bd02b | 788 | } |
| akashvibhute | 2:a5f8e04bd02b | 789 | |
| akashvibhute | 2:a5f8e04bd02b | 790 | /********************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 791 | |
| akashvibhute | 2:a5f8e04bd02b | 792 | bool RF24Network::write_to_pipe( uint16_t node, uint8_t pipe, bool multicast ) |
| akashvibhute | 0:c3db0798d9aa | 793 | { |
| akashvibhute | 3:dfc8da7ac18c | 794 | bool ok = false; |
| akashvibhute | 3:dfc8da7ac18c | 795 | uint64_t out_pipe = pipe_address( node, pipe ); |
| akashvibhute | 3:dfc8da7ac18c | 796 | |
| akashvibhute | 3:dfc8da7ac18c | 797 | #if !defined (DUAL_HEAD_RADIO) |
| akashvibhute | 3:dfc8da7ac18c | 798 | // Open the correct pipe for writing. |
| akashvibhute | 3:dfc8da7ac18c | 799 | // First, stop listening so we can talk |
| akashvibhute | 3:dfc8da7ac18c | 800 | |
| akashvibhute | 3:dfc8da7ac18c | 801 | if(!(networkFlags & FLAG_FAST_FRAG)) { |
| akashvibhute | 3:dfc8da7ac18c | 802 | radio.stopListening(); |
| akashvibhute | 3:dfc8da7ac18c | 803 | } |
| akashvibhute | 0:c3db0798d9aa | 804 | |
| akashvibhute | 3:dfc8da7ac18c | 805 | if(multicast) { |
| akashvibhute | 3:dfc8da7ac18c | 806 | radio.setAutoAck(0,0); |
| akashvibhute | 3:dfc8da7ac18c | 807 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 808 | radio.setAutoAck(0,1); |
| akashvibhute | 3:dfc8da7ac18c | 809 | } |
| akashvibhute | 3:dfc8da7ac18c | 810 | |
| akashvibhute | 3:dfc8da7ac18c | 811 | radio.openWritingPipe(out_pipe); |
| akashvibhute | 3:dfc8da7ac18c | 812 | radio.writeFast(frame_buffer, frame_size,multicast); |
| akashvibhute | 3:dfc8da7ac18c | 813 | ok = radio.txStandBy(txTimeout); |
| akashvibhute | 3:dfc8da7ac18c | 814 | |
| akashvibhute | 3:dfc8da7ac18c | 815 | radio.setAutoAck(0,0); |
| akashvibhute | 3:dfc8da7ac18c | 816 | |
| akashvibhute | 2:a5f8e04bd02b | 817 | #else |
| akashvibhute | 3:dfc8da7ac18c | 818 | radio1.openWritingPipe(out_pipe); |
| akashvibhute | 3:dfc8da7ac18c | 819 | radio1.writeFast(frame_buffer, frame_size); |
| akashvibhute | 3:dfc8da7ac18c | 820 | ok = radio1.txStandBy(txTimeout,multicast); |
| akashvibhute | 0:c3db0798d9aa | 821 | |
| akashvibhute | 2:a5f8e04bd02b | 822 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 823 | |
| akashvibhute | 3:dfc8da7ac18c | 824 | IF_SERIAL_DEBUG(printf_P(PSTR("%lu: MAC Sent on %lx %S\n\r"),rf24netTimer.read_ms(),(uint32_t)out_pipe,ok?PSTR("ok"):PSTR("failed"))); |
| akashvibhute | 2:a5f8e04bd02b | 825 | |
| akashvibhute | 3:dfc8da7ac18c | 826 | return ok; |
| akashvibhute | 0:c3db0798d9aa | 827 | } |
| akashvibhute | 0:c3db0798d9aa | 828 | |
| akashvibhute | 0:c3db0798d9aa | 829 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 830 | |
| akashvibhute | 0:c3db0798d9aa | 831 | const char* RF24NetworkHeader::toString(void) const |
| akashvibhute | 0:c3db0798d9aa | 832 | { |
| akashvibhute | 3:dfc8da7ac18c | 833 | static char buffer[45]; |
| akashvibhute | 3:dfc8da7ac18c | 834 | //snprintf_P(buffer,sizeof(buffer),PSTR("id %04x from 0%o to 0%o type %c"),id,from_node,to_node,type); |
| akashvibhute | 3:dfc8da7ac18c | 835 | sprintf(buffer,PSTR("id %u from 0%o to 0%o type %d"),id,from_node,to_node,type); |
| akashvibhute | 3:dfc8da7ac18c | 836 | return buffer; |
| akashvibhute | 0:c3db0798d9aa | 837 | } |
| akashvibhute | 0:c3db0798d9aa | 838 | |
| akashvibhute | 0:c3db0798d9aa | 839 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 840 | |
| akashvibhute | 0:c3db0798d9aa | 841 | bool RF24Network::is_direct_child( uint16_t node ) |
| akashvibhute | 0:c3db0798d9aa | 842 | { |
| akashvibhute | 3:dfc8da7ac18c | 843 | bool result = false; |
| akashvibhute | 0:c3db0798d9aa | 844 | |
| akashvibhute | 3:dfc8da7ac18c | 845 | // A direct child of ours has the same low numbers as us, and only |
| akashvibhute | 3:dfc8da7ac18c | 846 | // one higher number. |
| akashvibhute | 3:dfc8da7ac18c | 847 | // |
| akashvibhute | 3:dfc8da7ac18c | 848 | // e.g. node 0234 is a direct child of 034, and node 01234 is a |
| akashvibhute | 3:dfc8da7ac18c | 849 | // descendant but not a direct child |
| akashvibhute | 0:c3db0798d9aa | 850 | |
| akashvibhute | 3:dfc8da7ac18c | 851 | // First, is it even a descendant? |
| akashvibhute | 3:dfc8da7ac18c | 852 | if ( is_descendant(node) ) { |
| akashvibhute | 3:dfc8da7ac18c | 853 | // Does it only have ONE more level than us? |
| akashvibhute | 3:dfc8da7ac18c | 854 | uint16_t child_node_mask = ( ~ node_mask ) << 3; |
| akashvibhute | 3:dfc8da7ac18c | 855 | result = ( node & child_node_mask ) == 0 ; |
| akashvibhute | 3:dfc8da7ac18c | 856 | } |
| akashvibhute | 3:dfc8da7ac18c | 857 | return result; |
| akashvibhute | 0:c3db0798d9aa | 858 | } |
| akashvibhute | 0:c3db0798d9aa | 859 | |
| akashvibhute | 0:c3db0798d9aa | 860 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 861 | |
| akashvibhute | 0:c3db0798d9aa | 862 | bool RF24Network::is_descendant( uint16_t node ) |
| akashvibhute | 0:c3db0798d9aa | 863 | { |
| akashvibhute | 3:dfc8da7ac18c | 864 | return ( node & node_mask ) == node_address; |
| akashvibhute | 0:c3db0798d9aa | 865 | } |
| akashvibhute | 0:c3db0798d9aa | 866 | |
| akashvibhute | 0:c3db0798d9aa | 867 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 868 | |
| akashvibhute | 0:c3db0798d9aa | 869 | void RF24Network::setup_address(void) |
| akashvibhute | 0:c3db0798d9aa | 870 | { |
| akashvibhute | 3:dfc8da7ac18c | 871 | // First, establish the node_mask |
| akashvibhute | 3:dfc8da7ac18c | 872 | uint16_t node_mask_check = 0xFFFF; |
| akashvibhute | 3:dfc8da7ac18c | 873 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 874 | uint8_t count = 0; |
| akashvibhute | 3:dfc8da7ac18c | 875 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 876 | |
| akashvibhute | 3:dfc8da7ac18c | 877 | while ( node_address & node_mask_check ) { |
| akashvibhute | 3:dfc8da7ac18c | 878 | node_mask_check <<= 3; |
| akashvibhute | 3:dfc8da7ac18c | 879 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 880 | count++; |
| akashvibhute | 3:dfc8da7ac18c | 881 | } |
| akashvibhute | 3:dfc8da7ac18c | 882 | multicast_level = count; |
| akashvibhute | 3:dfc8da7ac18c | 883 | #else |
| akashvibhute | 3:dfc8da7ac18c | 884 | } |
| akashvibhute | 3:dfc8da7ac18c | 885 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 886 | |
| akashvibhute | 3:dfc8da7ac18c | 887 | node_mask = ~ node_mask_check; |
| akashvibhute | 0:c3db0798d9aa | 888 | |
| akashvibhute | 3:dfc8da7ac18c | 889 | // parent mask is the next level down |
| akashvibhute | 3:dfc8da7ac18c | 890 | uint16_t parent_mask = node_mask >> 3; |
| akashvibhute | 0:c3db0798d9aa | 891 | |
| akashvibhute | 3:dfc8da7ac18c | 892 | // parent node is the part IN the mask |
| akashvibhute | 3:dfc8da7ac18c | 893 | parent_node = node_address & parent_mask; |
| akashvibhute | 0:c3db0798d9aa | 894 | |
| akashvibhute | 3:dfc8da7ac18c | 895 | // parent pipe is the part OUT of the mask |
| akashvibhute | 3:dfc8da7ac18c | 896 | uint16_t i = node_address; |
| akashvibhute | 3:dfc8da7ac18c | 897 | uint16_t m = parent_mask; |
| akashvibhute | 3:dfc8da7ac18c | 898 | while (m) |
| akashvibhute | 3:dfc8da7ac18c | 899 | { |
| akashvibhute | 3:dfc8da7ac18c | 900 | i >>= 3; |
| akashvibhute | 3:dfc8da7ac18c | 901 | m >>= 3; |
| akashvibhute | 3:dfc8da7ac18c | 902 | } |
| akashvibhute | 3:dfc8da7ac18c | 903 | parent_pipe = i; |
| akashvibhute | 0:c3db0798d9aa | 904 | |
| akashvibhute | 3:dfc8da7ac18c | 905 | IF_SERIAL_DEBUG( printf_P(PSTR("setup_address node=0%o mask=0%o parent=0%o pipe=0%o\n\r"),node_address,node_mask,parent_node,parent_pipe);); |
| akashvibhute | 2:a5f8e04bd02b | 906 | |
| akashvibhute | 2:a5f8e04bd02b | 907 | } |
| akashvibhute | 2:a5f8e04bd02b | 908 | |
| akashvibhute | 2:a5f8e04bd02b | 909 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 910 | uint16_t RF24Network::addressOfPipe( uint16_t node, uint8_t pipeNo ) |
| akashvibhute | 2:a5f8e04bd02b | 911 | { |
| akashvibhute | 3:dfc8da7ac18c | 912 | //Say this node is 013 (1011), mask is 077 or (00111111) |
| akashvibhute | 3:dfc8da7ac18c | 913 | //Say we want to use pipe 3 (11) |
| akashvibhute | 3:dfc8da7ac18c | 914 | //6 bits in node mask, so shift pipeNo 6 times left and | into address |
| akashvibhute | 2:a5f8e04bd02b | 915 | uint16_t m = node_mask >> 3; |
| akashvibhute | 2:a5f8e04bd02b | 916 | uint8_t i=0; |
| akashvibhute | 3:dfc8da7ac18c | 917 | |
| akashvibhute | 3:dfc8da7ac18c | 918 | while (m) { //While there are bits left in the node mask |
| akashvibhute | 2:a5f8e04bd02b | 919 | m>>=1; //Shift to the right |
| akashvibhute | 2:a5f8e04bd02b | 920 | i++; //Count the # of increments |
| akashvibhute | 2:a5f8e04bd02b | 921 | } |
| akashvibhute | 3:dfc8da7ac18c | 922 | return node | (pipeNo << i); |
| akashvibhute | 0:c3db0798d9aa | 923 | } |
| akashvibhute | 0:c3db0798d9aa | 924 | |
| akashvibhute | 0:c3db0798d9aa | 925 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 926 | |
| akashvibhute | 0:c3db0798d9aa | 927 | uint16_t RF24Network::direct_child_route_to( uint16_t node ) |
| akashvibhute | 0:c3db0798d9aa | 928 | { |
| akashvibhute | 3:dfc8da7ac18c | 929 | // Presumes that this is in fact a child!! |
| akashvibhute | 3:dfc8da7ac18c | 930 | uint16_t child_mask = ( node_mask << 3 ) | 7; |
| akashvibhute | 3:dfc8da7ac18c | 931 | return node & child_mask; |
| akashvibhute | 3:dfc8da7ac18c | 932 | |
| akashvibhute | 0:c3db0798d9aa | 933 | } |
| akashvibhute | 0:c3db0798d9aa | 934 | |
| akashvibhute | 0:c3db0798d9aa | 935 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 936 | /* |
| akashvibhute | 0:c3db0798d9aa | 937 | uint8_t RF24Network::pipe_to_descendant( uint16_t node ) |
| akashvibhute | 0:c3db0798d9aa | 938 | { |
| akashvibhute | 3:dfc8da7ac18c | 939 | uint16_t i = node; |
| akashvibhute | 0:c3db0798d9aa | 940 | uint16_t m = node_mask; |
| akashvibhute | 2:a5f8e04bd02b | 941 | |
| akashvibhute | 0:c3db0798d9aa | 942 | while (m) |
| akashvibhute | 0:c3db0798d9aa | 943 | { |
| akashvibhute | 0:c3db0798d9aa | 944 | i >>= 3; |
| akashvibhute | 0:c3db0798d9aa | 945 | m >>= 3; |
| akashvibhute | 0:c3db0798d9aa | 946 | } |
| akashvibhute | 0:c3db0798d9aa | 947 | |
| akashvibhute | 2:a5f8e04bd02b | 948 | return i & 0B111; |
| akashvibhute | 2:a5f8e04bd02b | 949 | }*/ |
| akashvibhute | 0:c3db0798d9aa | 950 | |
| akashvibhute | 0:c3db0798d9aa | 951 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 952 | |
| akashvibhute | 2:a5f8e04bd02b | 953 | bool RF24Network::is_valid_address( uint16_t node ) |
| akashvibhute | 0:c3db0798d9aa | 954 | { |
| akashvibhute | 3:dfc8da7ac18c | 955 | bool result = true; |
| akashvibhute | 0:c3db0798d9aa | 956 | |
| akashvibhute | 3:dfc8da7ac18c | 957 | while(node) { |
| akashvibhute | 3:dfc8da7ac18c | 958 | uint8_t digit = node & 7; |
| akashvibhute | 3:dfc8da7ac18c | 959 | #if !defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 960 | if (digit < 1 || digit > 5) |
| akashvibhute | 3:dfc8da7ac18c | 961 | #else |
| akashvibhute | 3:dfc8da7ac18c | 962 | if (digit < 0 || digit > 5) //Allow our out of range multicast address |
| akashvibhute | 3:dfc8da7ac18c | 963 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 964 | { |
| akashvibhute | 3:dfc8da7ac18c | 965 | result = false; |
| akashvibhute | 3:dfc8da7ac18c | 966 | IF_SERIAL_DEBUG_MINIMAL(printf_P(PSTR("*** WARNING *** Invalid address 0%o\n\r"),node);); |
| akashvibhute | 3:dfc8da7ac18c | 967 | break; |
| akashvibhute | 3:dfc8da7ac18c | 968 | } |
| akashvibhute | 3:dfc8da7ac18c | 969 | node >>= 3; |
| akashvibhute | 0:c3db0798d9aa | 970 | } |
| akashvibhute | 0:c3db0798d9aa | 971 | |
| akashvibhute | 3:dfc8da7ac18c | 972 | return result; |
| akashvibhute | 0:c3db0798d9aa | 973 | } |
| akashvibhute | 0:c3db0798d9aa | 974 | |
| akashvibhute | 0:c3db0798d9aa | 975 | /******************************************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 976 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 977 | void RF24Network::multicastLevel(uint8_t level) |
| akashvibhute | 3:dfc8da7ac18c | 978 | { |
| akashvibhute | 3:dfc8da7ac18c | 979 | multicast_level = level; |
| akashvibhute | 3:dfc8da7ac18c | 980 | //radio.stopListening(); |
| akashvibhute | 3:dfc8da7ac18c | 981 | radio.openReadingPipe(0,pipe_address(levelToAddress(level),0)); |
| akashvibhute | 3:dfc8da7ac18c | 982 | //radio.startListening(); |
| akashvibhute | 3:dfc8da7ac18c | 983 | } |
| akashvibhute | 3:dfc8da7ac18c | 984 | |
| akashvibhute | 3:dfc8da7ac18c | 985 | uint16_t levelToAddress(uint8_t level) |
| akashvibhute | 3:dfc8da7ac18c | 986 | { |
| akashvibhute | 3:dfc8da7ac18c | 987 | |
| akashvibhute | 2:a5f8e04bd02b | 988 | uint16_t levelAddr = 1; |
| akashvibhute | 3:dfc8da7ac18c | 989 | if(level) { |
| akashvibhute | 2:a5f8e04bd02b | 990 | levelAddr = levelAddr << ((level-1) * 3); |
| akashvibhute | 3:dfc8da7ac18c | 991 | } else { |
| akashvibhute | 3:dfc8da7ac18c | 992 | return 0; |
| akashvibhute | 2:a5f8e04bd02b | 993 | } |
| akashvibhute | 2:a5f8e04bd02b | 994 | return levelAddr; |
| akashvibhute | 3:dfc8da7ac18c | 995 | } |
| akashvibhute | 2:a5f8e04bd02b | 996 | #endif |
| akashvibhute | 2:a5f8e04bd02b | 997 | /******************************************************************/ |
| akashvibhute | 0:c3db0798d9aa | 998 | |
| akashvibhute | 0:c3db0798d9aa | 999 | uint64_t pipe_address( uint16_t node, uint8_t pipe ) |
| akashvibhute | 0:c3db0798d9aa | 1000 | { |
| akashvibhute | 3:dfc8da7ac18c | 1001 | |
| akashvibhute | 3:dfc8da7ac18c | 1002 | static uint8_t address_translation[] = { 0xc3,0x3c,0x33,0xce,0x3e,0xe3,0xec }; |
| akashvibhute | 3:dfc8da7ac18c | 1003 | uint64_t result = 0xCCCCCCCCCCLL; |
| akashvibhute | 3:dfc8da7ac18c | 1004 | uint8_t* out = reinterpret_cast<uint8_t*>(&result); |
| akashvibhute | 3:dfc8da7ac18c | 1005 | |
| akashvibhute | 3:dfc8da7ac18c | 1006 | // Translate the address to use our optimally chosen radio address bytes |
| akashvibhute | 3:dfc8da7ac18c | 1007 | uint8_t count = 1; |
| akashvibhute | 3:dfc8da7ac18c | 1008 | uint16_t dec = node; |
| akashvibhute | 0:c3db0798d9aa | 1009 | |
| akashvibhute | 3:dfc8da7ac18c | 1010 | while(dec) { |
| akashvibhute | 3:dfc8da7ac18c | 1011 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 1012 | if(pipe != 0 || !node) |
| akashvibhute | 3:dfc8da7ac18c | 1013 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 1014 | out[count]=address_translation[(dec % 8)]; // Convert our decimal values to octal, translate them to address bytes, and set our address |
| akashvibhute | 3:dfc8da7ac18c | 1015 | |
| akashvibhute | 3:dfc8da7ac18c | 1016 | dec /= 8; |
| akashvibhute | 3:dfc8da7ac18c | 1017 | count++; |
| akashvibhute | 2:a5f8e04bd02b | 1018 | } |
| akashvibhute | 0:c3db0798d9aa | 1019 | |
| akashvibhute | 3:dfc8da7ac18c | 1020 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 1021 | if(pipe != 0 || !node) |
| akashvibhute | 3:dfc8da7ac18c | 1022 | #endif |
| akashvibhute | 3:dfc8da7ac18c | 1023 | out[0] = address_translation[pipe]; |
| akashvibhute | 3:dfc8da7ac18c | 1024 | #if defined (RF24NetworkMulticast) |
| akashvibhute | 3:dfc8da7ac18c | 1025 | else |
| akashvibhute | 3:dfc8da7ac18c | 1026 | out[1] = address_translation[count-1]; |
| akashvibhute | 3:dfc8da7ac18c | 1027 | #endif |
| akashvibhute | 0:c3db0798d9aa | 1028 | |
| akashvibhute | 0:c3db0798d9aa | 1029 | |
| pietor | 6:80195a45b25c | 1030 | IF_SERIAL_DEBUG(uint32_t* top = reinterpret_cast<uint32_t*>(out+1); printf_P(PSTR("NET Pipe %i on node 0%o has address %lx%x\n\r"),pipe,node,*top,*out)); |
| akashvibhute | 3:dfc8da7ac18c | 1031 | |
| akashvibhute | 3:dfc8da7ac18c | 1032 | return result; |
| akashvibhute | 0:c3db0798d9aa | 1033 | } |
| akashvibhute | 0:c3db0798d9aa | 1034 | |
| akashvibhute | 2:a5f8e04bd02b | 1035 | |
| akashvibhute | 2:a5f8e04bd02b | 1036 | /************************ Sleep Mode ******************************************/ |
| akashvibhute | 2:a5f8e04bd02b | 1037 | |
| akashvibhute | 2:a5f8e04bd02b | 1038 | #if defined ENABLE_SLEEP_MODE |
| akashvibhute | 2:a5f8e04bd02b | 1039 | |
| akashvibhute | 3:dfc8da7ac18c | 1040 | void wakeUp() |
| akashvibhute | 3:dfc8da7ac18c | 1041 | { |
| akashvibhute | 3:dfc8da7ac18c | 1042 | wasInterrupted=true; |
| akashvibhute | 3:dfc8da7ac18c | 1043 | sleep_cycles_remaining = 0; |
| akashvibhute | 2:a5f8e04bd02b | 1044 | } |
| akashvibhute | 2:a5f8e04bd02b | 1045 | |
| akashvibhute | 3:dfc8da7ac18c | 1046 | ISR(WDT_vect) |
| akashvibhute | 3:dfc8da7ac18c | 1047 | { |
| akashvibhute | 3:dfc8da7ac18c | 1048 | --sleep_cycles_remaining; |
| akashvibhute | 2:a5f8e04bd02b | 1049 | } |
| akashvibhute | 2:a5f8e04bd02b | 1050 | |
| akashvibhute | 2:a5f8e04bd02b | 1051 | |
| akashvibhute | 3:dfc8da7ac18c | 1052 | bool RF24Network::sleepNode( unsigned int cycles, int interruptPin ) |
| akashvibhute | 3:dfc8da7ac18c | 1053 | { |
| akashvibhute | 2:a5f8e04bd02b | 1054 | |
| akashvibhute | 2:a5f8e04bd02b | 1055 | |
| akashvibhute | 3:dfc8da7ac18c | 1056 | sleep_cycles_remaining = cycles; |
| akashvibhute | 3:dfc8da7ac18c | 1057 | set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here |
| akashvibhute | 3:dfc8da7ac18c | 1058 | sleep_enable(); |
| akashvibhute | 3:dfc8da7ac18c | 1059 | //if(interruptPin != 255){ |
| akashvibhute | 3:dfc8da7ac18c | 1060 | // wasInterrupted = false; //Reset Flag |
| akashvibhute | 3:dfc8da7ac18c | 1061 | // attachInterrupt(interruptPin,wakeUp, LOW); |
| akashvibhute | 3:dfc8da7ac18c | 1062 | //} |
| akashvibhute | 3:dfc8da7ac18c | 1063 | |
| akashvibhute | 3:dfc8da7ac18c | 1064 | WDTCSR |= _BV(WDIE); |
| akashvibhute | 3:dfc8da7ac18c | 1065 | |
| akashvibhute | 3:dfc8da7ac18c | 1066 | while(sleep_cycles_remaining) { |
| akashvibhute | 3:dfc8da7ac18c | 1067 | sleep_mode(); // System sleeps here |
| akashvibhute | 3:dfc8da7ac18c | 1068 | } // The WDT_vect interrupt wakes the MCU from here |
| akashvibhute | 3:dfc8da7ac18c | 1069 | sleep_disable(); // System continues execution here when watchdog timed out |
| akashvibhute | 3:dfc8da7ac18c | 1070 | //detachInterrupt(interruptPin); |
| akashvibhute | 3:dfc8da7ac18c | 1071 | |
| akashvibhute | 2:a5f8e04bd02b | 1072 | WDTCSR &= ~_BV(WDIE); |
| akashvibhute | 2:a5f8e04bd02b | 1073 | |
| akashvibhute | 3:dfc8da7ac18c | 1074 | return !wasInterrupted; |
| akashvibhute | 2:a5f8e04bd02b | 1075 | } |
| akashvibhute | 2:a5f8e04bd02b | 1076 | |
| akashvibhute | 3:dfc8da7ac18c | 1077 | void RF24Network::setup_watchdog(uint8_t prescalar) |
| akashvibhute | 3:dfc8da7ac18c | 1078 | { |
| akashvibhute | 2:a5f8e04bd02b | 1079 | |
| akashvibhute | 3:dfc8da7ac18c | 1080 | uint8_t wdtcsr = prescalar & 7; |
| akashvibhute | 3:dfc8da7ac18c | 1081 | if ( prescalar & 8 ) |
| akashvibhute | 3:dfc8da7ac18c | 1082 | wdtcsr |= _BV(WDP3); |
| akashvibhute | 3:dfc8da7ac18c | 1083 | MCUSR &= ~_BV(WDRF); // Clear the WD System Reset Flag |
| akashvibhute | 2:a5f8e04bd02b | 1084 | |
| akashvibhute | 3:dfc8da7ac18c | 1085 | WDTCSR = _BV(WDCE) | _BV(WDE); // Write the WD Change enable bit to enable changing the prescaler and enable system reset |
| akashvibhute | 3:dfc8da7ac18c | 1086 | WDTCSR = _BV(WDCE) | wdtcsr | _BV(WDIE); // Write the prescalar bits (how long to sleep, enable the interrupt to wake the MCU |
| akashvibhute | 2:a5f8e04bd02b | 1087 | } |
| akashvibhute | 2:a5f8e04bd02b | 1088 | |
| akashvibhute | 3:dfc8da7ac18c | 1089 | #endif |