Multi-Sensor Thermal Fence Alert

#include <Arduino.h>
#include <SPI.h>
#include <RadioLib.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <mbedtls/md.h>


// Forward declarations
void IRAM_ATTR onRadioReceive();
bool hasValidTag(const uint8_t *message, size_t length, const uint8_t *tag);
void addTag(uint8_t *message, size_t length);
void header(const char *text, uint16_t colour);
void beep(bool urgent);
uint16_t heatColour(uint8_t level);
void showReady();
void showAlert(uint8_t node, const char *kind);
void drawImage(uint8_t node);
void resetFrame(uint8_t node, uint8_t frame, uint8_t total);
void requestStoredImage();
void processPacket();

constexpr int LORA_NSS = 14;
constexpr int LORA_DIO0 = 32;
constexpr int LORA_RESET = 33;
constexpr int TFT_CS = 5;
constexpr int TFT_DC = 27;
constexpr int TFT_RST = 26;
constexpr int TOUCH_CS = 25;
constexpr int BUZZER_PIN = 4;
constexpr int REQUEST_BUTTON_PIN = 13;
constexpr int SPI_SCK = 18;
constexpr int SPI_MISO = 19;
constexpr int SPI_MOSI = 23;
constexpr uint8_t PACKET_MAGIC = 0xA7;
constexpr uint8_t IMAGE_PACKET = 0x01;
constexpr uint8_t TAMPER_PACKET = 0x02;
constexpr uint8_t ALERT_PACKET = 0x03;
constexpr uint8_t HEALTH_PACKET = 0x04;
constexpr uint8_t IMAGE_REQUEST_PACKET = 0x10;
constexpr uint8_t IMAGE_WIDTH = 32;
constexpr uint8_t IMAGE_HEIGHT = 24;
constexpr uint16_t IMAGE_PIXELS = IMAGE_WIDTH * IMAGE_HEIGHT;
constexpr uint8_t MAX_NODES = 12;
constexpr uint8_t MAX_CHUNKS = 12;
constexpr uint8_t HEADER_BYTES = 8;
constexpr uint8_t AUTH_BYTES = 8;
constexpr uint32_t FRAME_TIMEOUT_MS = 5000;
constexpr uint32_t BUTTON_DEBOUNCE_MS = 40;

// Replace this value before programming every receiver and fence controller.
// Each installation must use a private value not shared in labels or photographs.
const uint8_t AUTH_KEY[] = "FenceAlert-ChangeThisKey-2026!";
constexpr size_t AUTH_KEY_LENGTH = sizeof(AUTH_KEY) - 1;

Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);
SX1276 radio = new Module(LORA_NSS, LORA_DIO0, LORA_RESET, -1);
uint8_t imageBuffer[IMAGE_PIXELS];
bool chunkSeen[MAX_CHUNKS] = {false};
uint8_t activeNode = 0, activeFrame = 0, expectedChunks = 0, chunksReceived = 0;
uint8_t latestAlertNode = 0;
uint8_t newestFrame[MAX_NODES + 1] = {0};
bool frameKnown[MAX_NODES + 1] = {false};
uint32_t lastChunkAt = 0, lastAlertAt = 0, lastButtonChange = 0;
bool lastButtonState = HIGH;
volatile bool radioPacketReady = false;

void IRAM_ATTR onRadioReceive() { radioPacketReady = true; }

bool hasValidTag(const uint8_t *message, size_t length, const uint8_t *tag) {
  uint8_t digest[32];
  mbedtls_md_context_t context;
  mbedtls_md_init(&context);
  const mbedtls_md_info_t *info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
  int status = mbedtls_md_setup(&context, info, 1);
  if (status == 0) status = mbedtls_md_hmac_starts(&context, AUTH_KEY, AUTH_KEY_LENGTH);
  if (status == 0) status = mbedtls_md_hmac_update(&context, message, length);
  if (status == 0) status = mbedtls_md_hmac_finish(&context, digest);
  mbedtls_md_free(&context);
  if (status != 0) return false;
  uint8_t difference = 0;
  for (uint8_t i = 0; i < AUTH_BYTES; ++i) difference |= digest[i] ^ tag[i];
  return difference == 0;
}

void addTag(uint8_t *message, size_t length) {
  uint8_t digest[32];
  mbedtls_md_context_t context;
  mbedtls_md_init(&context);
  const mbedtls_md_info_t *info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
  mbedtls_md_setup(&context, info, 1);
  mbedtls_md_hmac_starts(&context, AUTH_KEY, AUTH_KEY_LENGTH);
  mbedtls_md_hmac_update(&context, message, length);
  mbedtls_md_hmac_finish(&context, digest);
  mbedtls_md_free(&context);
  memcpy(&message[length], digest, AUTH_BYTES);
}

void header(const char *text, uint16_t colour = ILI9341_NAVY) {
  tft.fillRect(0, 0, 320, 30, colour);
  tft.setTextColor(ILI9341_WHITE, colour);
  tft.setTextSize(2); tft.setCursor(6, 7); tft.print(text);
}

void beep(bool urgent = false) {
  ledcAttachPin(BUZZER_PIN, 0);
  for (uint8_t i = 0; i < (urgent ? 3 : 2); ++i) {
    ledcWriteTone(0, urgent ? 2500 : 1800); delay(90);
    ledcWriteTone(0, 0); delay(60);
  }
}

uint16_t heatColour(uint8_t level) {
  uint8_t r = 0, g = 0, b = 0;
  if (level < 64) b = 80 + level * 2;
  else if (level < 128) { g = (level - 64) * 4; b = 255 - (level - 64) * 4; }
  else if (level < 192) { r = (level - 128) * 4; g = 255; }
  else { r = 255; g = 255 - (level - 192) * 4; }
  return tft.color565(r, g, b);
}

void showReady() {
  tft.fillScreen(ILI9341_BLACK); header("THERMAL FENCE RECEIVER");
  tft.setTextColor(ILI9341_WHITE); tft.setTextSize(2); tft.setCursor(18, 72);
  tft.print("Listening for 12 sensors");
  tft.setTextSize(1); tft.setCursor(18, 108);
  tft.print("50 ft large warm-object zone");
  tft.setCursor(18, 128); tft.print("Short authenticated alerts only");
  tft.setCursor(18, 148); tft.print("Press button after an alert for heat image");
}

void showAlert(uint8_t node, const char *kind) {
  tft.fillScreen(ILI9341_BLACK); header(kind, ILI9341_RED);
  tft.setTextColor(ILI9341_YELLOW); tft.setTextSize(3); tft.setCursor(28, 75);
  tft.print("SENSOR "); tft.print(node);
  tft.setTextColor(ILI9341_WHITE); tft.setTextSize(2); tft.setCursor(28, 132);
  tft.print("Large warm object"); tft.setCursor(28, 158); tft.print("in its 50 ft zone");
  tft.setTextSize(1); tft.setCursor(28, 210);
  tft.print("Press the image button to request its stored heat frame.");
}

void drawImage(uint8_t node) {
  header("STORED THERMAL FRAME"); tft.fillRect(0, 30, 320, 216, ILI9341_BLACK);
  for (uint8_t y = 0; y < IMAGE_HEIGHT; ++y)
    for (uint8_t x = 0; x < IMAGE_WIDTH; ++x)
      tft.fillRect(32 + x * 8, 42 + y * 8, 8, 8, heatColour(imageBuffer[y * IMAGE_WIDTH + x]));
  tft.fillRect(0, 246, 320, 74, ILI9341_BLACK); tft.setTextSize(2); tft.setTextColor(ILI9341_WHITE);
  tft.setCursor(12, 254); tft.print("Sensor "); tft.print(node); tft.print(" stored frame");
  tft.setCursor(12, 282); tft.setTextColor(ILI9341_CYAN); tft.print("Blue=cool   Red=warm");
}

void resetFrame(uint8_t node, uint8_t frame, uint8_t total) {
  activeNode = node; activeFrame = frame; expectedChunks = total; chunksReceived = 0;
  memset(chunkSeen, 0, sizeof(chunkSeen)); memset(imageBuffer, 0, sizeof(imageBuffer));
}

void requestStoredImage() {
  if (latestAlertNode == 0) return;
  uint8_t packet[HEADER_BYTES + AUTH_BYTES] = {PACKET_MAGIC, IMAGE_REQUEST_PACKET, latestAlertNode, 0, 0, 0, 0, 0};
  addTag(packet, HEADER_BYTES);
  radio.standby();
  int state = radio.transmit(packet, sizeof(packet));
  radio.startReceive();
  if (state == RADIOLIB_ERR_NONE) {
    tft.fillRect(0, 210, 320, 28, ILI9341_BLACK); tft.setTextColor(ILI9341_CYAN); tft.setTextSize(1);
    tft.setCursor(28, 216); tft.print("Image requested from Sensor "); tft.print(latestAlertNode);
  }
}

void processPacket() {
  uint8_t packet[255]; int16_t length = radio.getPacketLength();
  if (length < HEADER_BYTES + AUTH_BYTES || length > 255) return;
  if (radio.readData(packet, length) != RADIOLIB_ERR_NONE) return;
  uint16_t signedLength = length - AUTH_BYTES;
  if (packet[0] != PACKET_MAGIC || !hasValidTag(packet, signedLength, &packet[signedLength])) return;
  uint8_t type = packet[1], node = packet[2], frame = packet[3];
  if (node < 1 || node > MAX_NODES) return;
  if (type == TAMPER_PACKET) { latestAlertNode = node; showAlert(node, "ENCLOSURE OPEN"); beep(true); return; }
  if (type == ALERT_PACKET) { latestAlertNode = node; showAlert(node, "THERMAL ALERT"); beep(); return; }
  if (type == HEALTH_PACKET) return;
  if (type != IMAGE_PACKET) return;
  uint8_t chunk = packet[4], total = packet[5];
  uint16_t offset = (uint16_t(packet[6]) << 8) | packet[7];
  uint16_t dataLength = signedLength - HEADER_BYTES;
  if (!total || total > MAX_CHUNKS || chunk >= total || offset >= IMAGE_PIXELS || offset + dataLength > IMAGE_PIXELS) return;
  if (node != activeNode || frame != activeFrame || total != expectedChunks || millis() - lastChunkAt > FRAME_TIMEOUT_MS) {
    if (frameKnown[node] && frame == newestFrame[node]) return;
    resetFrame(node, frame, total); newestFrame[node] = frame; frameKnown[node] = true;
  }
  if (!chunkSeen[chunk]) { memcpy(&imageBuffer[offset], &packet[HEADER_BYTES], dataLength); chunkSeen[chunk] = true; ++chunksReceived; }
  lastChunkAt = millis();
  if (chunksReceived == expectedChunks) drawImage(activeNode);
}

void setup() {
  pinMode(TOUCH_CS, OUTPUT); digitalWrite(TOUCH_CS, HIGH);
  pinMode(BUZZER_PIN, OUTPUT); pinMode(REQUEST_BUTTON_PIN, INPUT_PULLUP);
  SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI); tft.begin(); tft.setRotation(1); showReady();
  if (radio.begin(915.0, 125.0, 9, 7, 0x12, 17) != RADIOLIB_ERR_NONE) {
    tft.setTextColor(ILI9341_RED); tft.setTextSize(2); tft.setCursor(18, 175); tft.print("Radio wiring error"); while (true) delay(1000);
  }
  radio.setDio0Action(onRadioReceive); radio.startReceive();
}

void loop() {
  if (radioPacketReady) { radioPacketReady = false; processPacket(); radio.startReceive(); }
  bool now = digitalRead(REQUEST_BUTTON_PIN);
  if (now != lastButtonState && millis() - lastButtonChange > BUTTON_DEBOUNCE_MS) {
    lastButtonChange = millis(); lastButtonState = now;
    if (now == LOW) requestStoredImage();
  }
  if (activeNode && millis() - lastChunkAt > FRAME_TIMEOUT_MS) resetFrame(0, 0, 0);
  delay(5);
}