nRF24, battery

#include <RF24.h>
#include <RF24Network.h>

#define BLOCK_SIZE 16
byte payload[BLOCK_SIZE];   // TX buffer
byte rxBuffer[BLOCK_SIZE];  // RX buffer

// Only for have numbers of bytes in payload with human readable names
enum payloadPointer { _NodeH = 0, _NodeL = 1, _Battery = 2, _MsgType = 3, _MsgVal = 4};
enum messageType { CMD0 = 10, CMD1 = 11, CMD2 = 12, CMD3 = 13, CMD4 = 14, CMD5 = 15 };

unsigned long TimeStamp = 9999;
unsigned long RxTimeout = 0;

// SCK = 13, MOSI = 11, MISO = 12.
RF24 radio(10,9);                   // (CE, SSN) nRF24L01(+) radio attached using Getting Started board
RF24Network network(radio);         // Network uses that radio
const uint16_t master_node = 00;    // Address of the other node in Octal format
uint16_t this_node = 01;            // Address of our node in Octal format ( 04,031, etc)
unsigned long t1, t2;
uint16_t battery = 0;



// ***************************************************************************************************** //
// *****************************************    SETUP   ************************************************ //
// ***************************************************************************************************** //
void setup(){
  analogReference(INTERNAL);

  Serial.begin(115200);
  Serial.println();

  Serial.print(F("Node address: "));
  Serial.println(this_node);

  // Init nRF24 Network
  SPI.begin();
  radio.begin();
  radio.setRetries(5, 10);
  radio.setDataRate(RF24_250KBPS);
  network.begin(/*channel*/ 90, /*node address*/ this_node);
}



// ***************************************************************************************************** //
// *****************************************    LOOP   ************************************************* //
// ***************************************************************************************************** //

void loop(){
  // Get data from nRF24L01+
  getRadioData();

  // First info: node address
  payload[_NodeH] = (byte)((this_node >> 8) & 0xff);
  payload[_NodeL] = (byte)(this_node & 0xff);

  battery = readVcc();
  Serial.print(F("Battery mV: "));
  Serial.println(battery);

  // Now the battery level
  payload[_Battery + 0] = (byte)((battery >> 8) & 0xff);
  payload[_Battery + 1] = (byte)(battery & 0xff);

  // And finally message type + value
  payload[_MsgType] = CMD0;
  payload[_MsgVal] = 0;

  // Now we can send the payload buffer fitted with info
  Serial.print(F("Send message: "));
  if( sendRadioData()) {
    Serial.print(F(" ..OK"));
  }
  else {
    Serial.print(F(" ..Fail"));
  }

  delay(100);
}


// ***************************************************************************************************** //
// *****************************************    RF24   ************************************************* //
// ***************************************************************************************************** //
void getRadioData(void) {
  network.update();
  while (network.available()) {
    RF24NetworkHeader Header;
    network.peek(Header);
    if (Header.to_node == this_node) {
      network.read(Header, &rxBuffer, sizeof(rxBuffer));
      // DEBUG
      Serial.print(F("\nrxBuffer:"));
      printHex(payload, BLOCK_SIZE);
    }
  }
}


bool sendRadioData() {
  bool TxOK = false;

  // DEBUG
  Serial.print("\nPayload: ");
  printHex(payload, BLOCK_SIZE);

  RF24NetworkHeader header(/*to node*/ master_node);
  if (network.write(header, &payload, sizeof(payload)))
    TxOK = true;
  return TxOK;
}



uint16_t readVcc() {
  uint16_t result;
  // Read 1.1V reference against AVcc
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  //delayMicroseconds(50);  // Wait for Vref to settle
  ADCSRA |= _BV(ADSC);    // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = 1126400L / result; // Back-calculate AVcc in mV
  return result;
}


// Helper routine to dump a byte array as hex values to Serial.
void printHex(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], HEX);
  }
}