IoT Crop Guardian Drone

#include <Arduino.h>
#include "esp_camera.h"
#include <WiFi.h>
#include <WebServer.h>
#include <HTTPClient.h>

// AI Thinker ESP32-CAM camera wiring is fixed on the board.
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

constexpr int PIR_PIN = 13;
constexpr int DFPLAYER_RX_PIN = 3;  // DFPlayer TX -> ESP32-CAM RX0
constexpr int DFPLAYER_TX_PIN = 1;  // DFPlayer RX -> ESP32-CAM TX0
constexpr int FLASH_LED_PIN = 4;    // white flash LED already fitted to the ESP32-CAM

const char *AP_SSID = "CropGuard-Node";
const char *AP_PASSWORD = "CropGuard1";
const char *PI_UPLOAD_URL = "http://192.168.4.2:8080/cropguard/photo";
const char *NODE_ID = "field-node-01";
const char *NODE_LOCATION = "replace-with-field-GPS-location";

WebServer server(80);
HardwareSerial &dfSerial = Serial;
bool alarmActive = false;
bool motionArmed = true;
uint32_t alarmStartedAt = 0;
uint32_t lastFlashAt = 0;
uint32_t eventCount = 0;
const uint32_t ALARM_DURATION_MS = 60000;
const uint32_t FLASH_INTERVAL_MS = 250;

uint16_t dfChecksum(uint8_t command, uint16_t parameter) {
  return 0U - (0xFF + 0x06 + command + (parameter >> 8) + (parameter & 0xFF));
}

void dfCommand(uint8_t command, uint16_t parameter) {
  const uint16_t check = dfChecksum(command, parameter);
  const uint8_t packet[] = {0x7E, 0xFF, 0x06, command, 0x00,
    static_cast<uint8_t>(parameter >> 8), static_cast<uint8_t>(parameter),
    static_cast<uint8_t>(check >> 8), static_cast<uint8_t>(check), 0xEF};
  dfSerial.write(packet, sizeof(packet));
}

void playRandomDeterrentSound() {
  dfCommand(0x03, random(1, 4)); // /mp3/0001.mp3 to /mp3/0003.mp3
}

bool captureAndUpload() {
  camera_fb_t *frame = esp_camera_fb_get();
  if (frame == nullptr) return false;
  HTTPClient http;
  http.setConnectTimeout(1500);
  http.setTimeout(3500);
  http.begin(PI_UPLOAD_URL);
  http.addHeader("Content-Type", "image/jpeg");
  http.addHeader("X-CropGuard-Node", NODE_ID);
  http.addHeader("X-CropGuard-Location", NODE_LOCATION);
  http.addHeader("X-CropGuard-Event", String(eventCount));
  const int result = http.POST(frame->buf, frame->len);
  http.end();
  esp_camera_fb_return(frame);
  return result >= 200 && result < 300;
}

void startAlarm() {
  if (alarmActive) return;
  eventCount++;
  captureAndUpload();
  playRandomDeterrentSound();
  alarmActive = true;
  alarmStartedAt = millis();
  lastFlashAt = 0;
  digitalWrite(FLASH_LED_PIN, HIGH);
}

void handleStatus() {
  String json = "{\"node\":\"" + String(NODE_ID) + "\",\"alarm\":";
  json += alarmActive ? "true" : "false";
  json += ",\"events\":" + String(eventCount) + "}";
  server.send(200, "application/json", json);
}

void handleSound() {
  startAlarm();
  server.send(200, "text/plain", "Level 1 sound and light started");
}

void handleCapture() {
  eventCount++;
  const bool uploaded = captureAndUpload();
  server.send(uploaded ? 200 : 503, "text/plain", uploaded ? "Photo sent to Raspberry Pi" : "Photo captured but Raspberry Pi did not accept it");
}

bool initCamera() {
  camera_config_t config = {};
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  config.frame_size = FRAMESIZE_VGA;
  config.jpeg_quality = 12;
  config.fb_count = psramFound() ? 2 : 1;
  return esp_camera_init(&config) == ESP_OK;
}

void setup() {
  pinMode(PIR_PIN, INPUT);
  pinMode(FLASH_LED_PIN, OUTPUT);
  digitalWrite(FLASH_LED_PIN, LOW);
  // UART0 is shared with programming: unplug DFPlayer TX/RX before flashing.
  dfSerial.begin(9600, SERIAL_8N1, DFPLAYER_RX_PIN, DFPLAYER_TX_PIN);
  delay(1200);
  dfCommand(0x3F, 0);
  delay(500);
  dfCommand(0x06, 25);
  initCamera();
  randomSeed(micros());
  WiFi.mode(WIFI_AP);
  WiFi.softAP(AP_SSID, AP_PASSWORD);
  server.on("/status", HTTP_GET, handleStatus);
  server.on("/sound", HTTP_GET, handleSound);
  server.on("/capture", HTTP_GET, handleCapture);
  server.begin();
}

void loop() {
  server.handleClient();
  const bool motionNow = digitalRead(PIR_PIN) == HIGH;
  if (!motionNow) motionArmed = true;
  if (motionNow && motionArmed && !alarmActive) {
    motionArmed = false;
    startAlarm();
  }
  if (alarmActive) {
    const uint32_t now = millis();
    if (now - lastFlashAt >= FLASH_INTERVAL_MS) {
      lastFlashAt = now;
      digitalWrite(FLASH_LED_PIN, !digitalRead(FLASH_LED_PIN));
    }
    if (now - alarmStartedAt >= ALARM_DURATION_MS) {
      alarmActive = false;
      digitalWrite(FLASH_LED_PIN, LOW);
      dfCommand(0x16, 0);
    }
  }
  delay(10);
}