nRF24L01 sensor network with RF24Network on an Arduino Uno

// nRF24L01 sensor network, the base: node 00 of an RF24Network. Two sensor
// nodes (01 and 02) each send their DS18B20's temperature every 2 seconds,
// and this board shows the last reading from each on a 16x2 I2C LCD. A node
// that has not reported for 10 seconds reads "no report".
//
//   nRF24L01  CE -> 7   CSN -> 8   SCK -> 13   MOSI -> 11   MISO -> 12
//             VCC -> 3.3V (never 5 V)   GND -> GND
//   LCD       SDA -> A4   SCL -> A5   VCC -> 5V   GND -> GND
//
// RF24Network gives each radio an octal address in a tree: 00 is the base,
// 01 to 05 its children. The network layer acknowledges each message, so a
// node knows whether the base got it. On the bench, put a 10 uF capacitor
// across the radio's VCC and GND: the module draws its current in bursts.
//
// Things to try. Drag a node's thermometer and watch its line change.
// Change SILENT_MS to notice a quiet node sooner.

#include <SPI.h>
#include <RF24.h>
#include <RF24Network.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

RF24 radio(7, 8);  // CE, CSN
RF24Network network(radio);
LiquidCrystal_I2C lcd(0x27, 16, 2);

const uint16_t THIS_NODE = 00;  // the base, in octal
const uint8_t CHANNEL = 90;     // every node must use the same channel
const unsigned long SILENT_MS = 10000;

// What a node sends: hundredths of a degree and a running count.
struct Reading {
  int16_t centiC;
  uint16_t count;
};

struct Node {
  bool heard;
  bool silent;
  unsigned long at;
  Reading last;
};
Node nodes[2];

unsigned long lastDraw = 0;

void printTemp(Print &out, int16_t centiC) {
  out.print(centiC / 100.0, 1);
  out.print(" C");
}

void draw() {
  for (uint8_t i = 0; i < 2; i++) {
    lcd.setCursor(0, i);
    lcd.print("Node 0");
    lcd.print(i + 1);
    lcd.print(": ");
    if (!nodes[i].heard) {
      lcd.print("waiting  ");
    } else if (nodes[i].silent) {
      lcd.print("no report");
    } else {
      printTemp(lcd, nodes[i].last.centiC);
      lcd.print("   ");
    }
  }
}

void setup() {
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  if (!radio.begin()) {
    Serial.println("radio not responding: check CE, CSN and the 3.3 V supply");
    lcd.print("No radio");
    while (1) {}
  }
  radio.setChannel(CHANNEL);
  network.begin(THIS_NODE);
  Serial.println("base 00 listening");
  draw();
}

void loop() {
  network.update();
  while (network.available()) {
    RF24NetworkHeader header;
    Reading r;
    network.read(header, &r, sizeof(r));
    uint16_t from = header.from_node;
    if (header.type != 'T' || from < 1 || from > 2) continue;
    Node &n = nodes[from - 1];
    n.heard = true;
    n.silent = false;
    n.at = millis();
    n.last = r;
    Serial.print("node 0");
    Serial.print(from);
    Serial.print(": ");
    printTemp(Serial, r.centiC);
    Serial.print(" (reading ");
    Serial.print(r.count);
    Serial.println(")");
  }

  for (uint8_t i = 0; i < 2; i++) {
    if (nodes[i].heard && !nodes[i].silent && millis() - nodes[i].at > SILENT_MS) {
      nodes[i].silent = true;
      Serial.print("node 0");
      Serial.print(i + 1);
      Serial.println(": no report for 10 s");
    }
  }

  if (millis() - lastDraw >= 500) {
    lastDraw = millis();
    draw();
  }
}

// nRF24L01 sensor network, a sensor node: node 01 of an RF24Network. Every
// 2 seconds it reads its DS18B20 and sends the temperature to the base,
// node 00, which shows it on an LCD. Node 02 runs the same sketch with
// THIS_NODE = 02.
//
//   nRF24L01  CE -> 7   CSN -> 8   SCK -> 13   MOSI -> 11   MISO -> 12
//             VCC -> 3.3V (never 5 V)   GND -> GND
//   DS18B20   DQ -> 4, with a 4.7 kohm pull-up to 5V (on the module)
//
// network.write() returns true once the base has acknowledged the message,
// so the serial monitor says whether each reading got through.
//
// Things to try. Change THIS_NODE to 03 and the base ignores it: it only
// shows nodes 01 and 02. Change INTERVAL_MS to report more often.

#include <SPI.h>
#include <RF24.h>
#include <RF24Network.h>
#include <OneWire.h>
#include <DallasTemperature.h>

RF24 radio(7, 8);  // CE, CSN
RF24Network network(radio);
OneWire oneWire(4);
DallasTemperature sensors(&oneWire);

const uint16_t THIS_NODE = 01;  // this node, in octal
const uint16_t BASE_NODE = 00;
const uint8_t CHANNEL = 90;
const unsigned long INTERVAL_MS = 2000;

struct Reading {
  int16_t centiC;
  uint16_t count;
};

unsigned long lastSent = 0;
uint16_t count = 0;

void setup() {
  Serial.begin(9600);
  sensors.begin();
  if (!radio.begin()) {
    Serial.println("radio not responding: check CE, CSN and the 3.3 V supply");
    while (1) {}
  }
  radio.setChannel(CHANNEL);
  network.begin(THIS_NODE);
  Serial.print("node 0");
  Serial.print(THIS_NODE);
  Serial.println(" sending to the base");
}

void loop() {
  network.update();
  if (millis() - lastSent < INTERVAL_MS) return;
  lastSent = millis();

  sensors.requestTemperatures();
  float c = sensors.getTempCByIndex(0);
  if (c == DEVICE_DISCONNECTED_C) {
    Serial.println("no DS18B20 on pin 4");
    return;
  }
  Reading r = {(int16_t)lround(c * 100), ++count};
  RF24NetworkHeader header(BASE_NODE, 'T');
  bool ok = network.write(header, &r, sizeof(r));
  Serial.print(c, 2);
  Serial.print(" C sent: ");
  Serial.println(ok ? "ok" : "no answer from the base");
}

// nRF24L01 sensor network, a sensor node: node 02 of an RF24Network. Every
// 2 seconds it reads its DS18B20 and sends the temperature to the base,
// node 00, which shows it on an LCD. Node 01 runs the same sketch with
// THIS_NODE = 01.
//
//   nRF24L01  CE -> 7   CSN -> 8   SCK -> 13   MOSI -> 11   MISO -> 12
//             VCC -> 3.3V (never 5 V)   GND -> GND
//   DS18B20   DQ -> 4, with a 4.7 kohm pull-up to 5V (on the module)
//
// network.write() returns true once the base has acknowledged the message,
// so the serial monitor says whether each reading got through.
//
// Things to try. Change THIS_NODE to 03 and the base ignores it: it only
// shows nodes 01 and 02. Change INTERVAL_MS to report more often.

#include <SPI.h>
#include <RF24.h>
#include <RF24Network.h>
#include <OneWire.h>
#include <DallasTemperature.h>

RF24 radio(7, 8);  // CE, CSN
RF24Network network(radio);
OneWire oneWire(4);
DallasTemperature sensors(&oneWire);

const uint16_t THIS_NODE = 02;  // this node, in octal
const uint16_t BASE_NODE = 00;
const uint8_t CHANNEL = 90;
const unsigned long INTERVAL_MS = 2000;

struct Reading {
  int16_t centiC;
  uint16_t count;
};

unsigned long lastSent = 0;
uint16_t count = 0;

void setup() {
  Serial.begin(9600);
  sensors.begin();
  if (!radio.begin()) {
    Serial.println("radio not responding: check CE, CSN and the 3.3 V supply");
    while (1) {}
  }
  radio.setChannel(CHANNEL);
  network.begin(THIS_NODE);
  Serial.print("node 0");
  Serial.print(THIS_NODE);
  Serial.println(" sending to the base");
}

void loop() {
  network.update();
  if (millis() - lastSent < INTERVAL_MS) return;
  lastSent = millis();

  sensors.requestTemperatures();
  float c = sensors.getTempCByIndex(0);
  if (c == DEVICE_DISCONNECTED_C) {
    Serial.println("no DS18B20 on pin 4");
    return;
  }
  Reading r = {(int16_t)lround(c * 100), ++count};
  RF24NetworkHeader header(BASE_NODE, 'T');
  bool ok = network.write(header, &r, sizeof(r));
  Serial.print(c, 2);
  Serial.print(" C sent: ");
  Serial.println(ok ? "ok" : "no answer from the base");
}