20km ESP32 Radio Network

#include <SPI.h>
#include <LoRa.h>
#include <Preferences.h>

// ESP32 DevKit v1 to RFM95W connections.
#define LORA_SCK 18
#define LORA_MISO 19
#define LORA_MOSI 23
#define LORA_NSS 4
#define LORA_RESET 27
#define LORA_DIO0 26

// India IN865 plan: use only after confirming the channel and EIRP are permitted
// for the installation with the applicable Indian wireless authority.
const long LORA_FREQUENCY_HZ = 866500000L;
const int LORA_TX_POWER_DBM = 14;
const unsigned long ACK_TIMEOUT_MS = 3000;
const int MAX_SEND_ATTEMPTS = 3;
const int MAX_SEEN = 20;

Preferences preferences;
String nodeId;
String seenIds[MAX_SEEN];
int seenNext = 0;
String pendingPacket;
String pendingId;
unsigned long pendingAt = 0;
int pendingAttempts = 0;
unsigned long nextMessageNumber = 1;

String fieldAt(const String &packet, int wanted) {
  int start = 0;
  for (int field = 0; field < wanted; field++) {
    int divider = packet.indexOf('|', start);
    if (divider < 0) return "";
    start = divider + 1;
  }
  int end = packet.indexOf('|', start);
  return end < 0 ? packet.substring(start) : packet.substring(start, end);
}

bool alreadySeen(const String &id) {
  for (int i = 0; i < MAX_SEEN; i++) {
    if (seenIds[i] == id) return true;
  }
  return false;
}

void remember(const String &id) {
  seenIds[seenNext] = id;
  seenNext = (seenNext + 1) % MAX_SEEN;
}

void transmit(const String &packet) {
  LoRa.idle();
  LoRa.beginPacket();
  LoRa.print(packet);
  LoRa.endPacket();
  LoRa.receive();
  Serial.println("TX " + packet);
}

bool validRole(const String &role) {
  return role == "A" || role == "B" || role == "R";
}

void configureRole(const String &role) {
  if (!validRole(role)) {
    Serial.println("Use CONFIG A, CONFIG B, or CONFIG R.");
    return;
  }
  nodeId = role;
  preferences.putString("role", nodeId);
  Serial.println("This station is now " + nodeId + ". Restarting radio receive.");
}

void queueMessage(const String &destination, String text) {
  if (nodeId != "A" && nodeId != "B") {
    Serial.println("Only endpoint A or B may create messages. Configure this unit first.");
    return;
  }
  if ((destination != "A" && destination != "B") || destination == nodeId) {
    Serial.println("Use TO A message or TO B message, addressed to the other endpoint.");
    return;
  }
  text.replace("|", "/");
  text.trim();
  if (text.length() == 0 || text.length() > 100) {
    Serial.println("Message must contain 1 to 100 characters.");
    return;
  }
  pendingId = nodeId + String(nextMessageNumber++);
  pendingPacket = "M|" + pendingId + "|" + nodeId + "|" + destination + "|3|" + text;
  pendingAttempts = 1;
  pendingAt = millis();
  remember(pendingId);
  transmit(pendingPacket);
}

void forwardPacket(const String &type, const String &id, const String &from,
                   const String &to, int ttl, const String &text) {
  if (ttl <= 0) return;
  String packet = type + "|" + id + "|" + from + "|" + to + "|" + String(ttl - 1) + "|" + text;
  delay(120 + random(180));
  transmit(packet);
}

void handlePacket(String packet) {
  String type = fieldAt(packet, 0);
  String id = fieldAt(packet, 1);
  String from = fieldAt(packet, 2);
  String to = fieldAt(packet, 3);
  int ttl = fieldAt(packet, 4).toInt();
  String text = fieldAt(packet, 5);
  if ((type != "M" && type != "A") || id.length() == 0 || !validRole(from) ||
      !validRole(to) || ttl < 0 || ttl > 3) return;

  if (alreadySeen(type + id)) return;
  remember(type + id);
  Serial.println("RX " + packet + " RSSI=" + String(LoRa.packetRssi()));

  if (nodeId == "R") {
    forwardPacket(type, id, from, to, ttl, text);
    return;
  }

  if (to != nodeId) return;
  if (type == "M") {
    Serial.println("MESSAGE FROM " + from + ": " + text);
    String acknowledgement = "A|" + id + "|" + nodeId + "|" + from + "|3|OK";
    transmit(acknowledgement);
  } else if (type == "A" && id == pendingId) {
    Serial.println("DELIVERED: message " + id + " was acknowledged by " + from);
    pendingPacket = "";
    pendingId = "";
    pendingAttempts = 0;
  }
}

void handleSerialLine(String line) {
  line.trim();
  if (line.startsWith("CONFIG ")) {
    String role = line.substring(7);
    role.trim();
    role.toUpperCase();
    configureRole(role);
  } else if (line.startsWith("TO ")) {
    int space = line.indexOf(' ', 3);
    if (space < 0) {
      Serial.println("Example: TO B Trail gate closed");
      return;
    }
    String destination = line.substring(3, space);
    destination.toUpperCase();
    queueMessage(destination, line.substring(space + 1));
  } else if (line == "STATUS") {
    Serial.println("ROLE=" + (nodeId.length() ? nodeId : "UNSET") +
                   " RSSI=" + String(LoRa.packetRssi()));
  } else if (line.length()) {
    Serial.println("Commands: CONFIG A, CONFIG B, CONFIG R, TO A/B message, STATUS");
  }
}

void setup() {
  Serial.begin(115200);
  delay(300);
  randomSeed((uint32_t)esp_random());
  preferences.begin("forestlora", false);
  nodeId = preferences.getString("role", "");

  SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_NSS);
  LoRa.setPins(LORA_NSS, LORA_RESET, LORA_DIO0);
  if (!LoRa.begin(LORA_FREQUENCY_HZ)) {
    Serial.println("LoRa radio was not found. Check 3.3 V, ground, and the five signal wires.");
    while (true) delay(1000);
  }
  LoRa.setTxPower(LORA_TX_POWER_DBM, PA_OUTPUT_PA_BOOST_PIN);
  LoRa.setSpreadingFactor(10);
  LoRa.setSignalBandwidth(125E3);
  LoRa.setCodingRate4(5);
  LoRa.setPreambleLength(12);
  LoRa.enableCrc();
  LoRa.receive();

  Serial.println("Forest relay network ready. Stored role: " + (nodeId.length() ? nodeId : "UNSET"));
  Serial.println("Configure the three boards once: CONFIG A, CONFIG B, CONFIG R.");
}

void loop() {
  while (Serial.available()) {
    String line = Serial.readStringUntil('\n');
    handleSerialLine(line);
  }

  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    String packet;
    while (LoRa.available()) packet += (char)LoRa.read();
    handlePacket(packet);
  }

  if (pendingPacket.length() && millis() - pendingAt >= ACK_TIMEOUT_MS) {
    if (pendingAttempts < MAX_SEND_ATTEMPTS) {
      pendingAttempts++;
      pendingAt = millis();
      Serial.println("No acknowledgement yet; retrying " + pendingId);
      transmit(pendingPacket);
    } else {
      Serial.println("NOT DELIVERED: no acknowledgement after three sends.");
      pendingPacket = "";
      pendingId = "";
    }
  }
  delay(5);
}