ESP32 Environmental Security Monitor

#include <Arduino.h>
#include <SPI.h>
#include <RadioLib.h>
#include <driver/i2s.h>


// Forward declarations
void IRAM_ATTR onRfPacket();
bool eventAllowed();
void reportEvent(const char *eventName, int32_t value);
void setupI2sMicrophone();
int32_t readMicrophoneLevel();
void setupRadio();
void checkRadio();
void checkDigitalSensors();
void checkMicrophone();

constexpr int CC1101_CS_PIN = 10;
constexpr int CC1101_MOSI_PIN = 11;
constexpr int CC1101_SCK_PIN = 12;
constexpr int CC1101_MISO_PIN = 13;
constexpr int CC1101_GDO0_PIN = 14;
constexpr int MIC_SCK_PIN = 15;
constexpr int MIC_WS_PIN = 16;
constexpr int MIC_SD_PIN = 17;
constexpr int VIBRATION_PIN = 18;
constexpr int SOUND_TRIGGER_PIN = 21;

constexpr uint32_t EVENT_COOLDOWN_MS = 1500;
constexpr uint32_t SOUND_SAMPLE_INTERVAL_MS = 250;
constexpr int32_t MIC_EVENT_LEVEL = 180000;

SPIClass radioSpi(FSPI);
CC1101 radio = new Module(CC1101_CS_PIN, CC1101_GDO0_PIN, RADIOLIB_NC, RADIOLIB_NC, radioSpi);
volatile bool rfPacketReady = false;
bool radioReady = false;
uint32_t lastEventAt = 0;
uint32_t lastMicSampleAt = 0;
int lastVibrationState = HIGH;
int lastSoundState = HIGH;

void IRAM_ATTR onRfPacket() {
  rfPacketReady = true;
}

bool eventAllowed() {
  const uint32_t now = millis();
  if (now - lastEventAt < EVENT_COOLDOWN_MS) {
    return false;
  }
  lastEventAt = now;
  return true;
}

void reportEvent(const char *eventName, int32_t value = 0) {
  if (eventAllowed()) {
    Serial.printf("EVENT,%lu,%s,%ld\n", millis(), eventName, static_cast<long>(value));
  }
}

void setupI2sMicrophone() {
  const i2s_config_t config = {
    .mode = static_cast<i2s_mode_t>(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = 16000,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = 0,
    .dma_buf_count = 4,
    .dma_buf_len = 64,
    .use_apll = false,
    .tx_desc_auto_clear = false,
    .fixed_mclk = 0
  };
  const i2s_pin_config_t pins = {
    .bck_io_num = MIC_SCK_PIN,
    .ws_io_num = MIC_WS_PIN,
    .data_out_num = I2S_PIN_NO_CHANGE,
    .data_in_num = MIC_SD_PIN
  };
  i2s_driver_install(I2S_NUM_0, &config, 0, nullptr);
  i2s_set_pin(I2S_NUM_0, &pins);
}

int32_t readMicrophoneLevel() {
  int32_t samples[64];
  size_t bytesRead = 0;
  const esp_err_t result = i2s_read(I2S_NUM_0, samples, sizeof(samples), &bytesRead, 20 / portTICK_PERIOD_MS);
  if (result != ESP_OK || bytesRead < sizeof(int32_t)) {
    return 0;
  }

  const size_t count = bytesRead / sizeof(int32_t);
  int64_t total = 0;
  for (size_t i = 0; i < count; ++i) {
    const int32_t sample = samples[i] >> 8;
    total += sample < 0 ? -static_cast<int64_t>(sample) : sample;
  }
  return static_cast<int32_t>(total / count);
}

void setupRadio() {
  radioSpi.begin(CC1101_SCK_PIN, CC1101_MISO_PIN, CC1101_MOSI_PIN, CC1101_CS_PIN);
  const int state = radio.begin(433.92);
  if (state == RADIOLIB_ERR_NONE) {
    radio.setGdo0Action(onRfPacket);
    radio.startReceive();
    radioReady = true;
    Serial.println("RF receiver ready at 433.92 MHz");
  } else {
    Serial.printf("RF receiver not detected, RadioLib error %d\n", state);
  }
}

void checkRadio() {
  if (!radioReady || !rfPacketReady) {
    return;
  }
  rfPacketReady = false;
  String message;
  const int state = radio.readData(message);
  if (state == RADIOLIB_ERR_NONE) {
    Serial.printf("RF_MESSAGE,%lu,%s\n", millis(), message.c_str());
    reportEvent("RF_MESSAGE");
  } else {
    Serial.printf("RF packet ignored, RadioLib error %d\n", state);
  }
  radio.startReceive();
}

void checkDigitalSensors() {
  const int vibrationState = digitalRead(VIBRATION_PIN);
  if (vibrationState != lastVibrationState) {
    lastVibrationState = vibrationState;
    reportEvent("VIBRATION", vibrationState);
  }

  const int soundState = digitalRead(SOUND_TRIGGER_PIN);
  if (soundState == LOW && lastSoundState == HIGH) {
    reportEvent("LOUD_SOUND_TRIGGER");
  }
  lastSoundState = soundState;
}

void checkMicrophone() {
  if (millis() - lastMicSampleAt < SOUND_SAMPLE_INTERVAL_MS) {
    return;
  }
  lastMicSampleAt = millis();
  const int32_t level = readMicrophoneLevel();
  Serial.printf("MIC_LEVEL,%lu,%ld\n", millis(), static_cast<long>(level));
  if (level >= MIC_EVENT_LEVEL) {
    reportEvent("MIC_LOUD_SOUND", level);
  }
}

void setup() {
  Serial.begin(115200);
  delay(300);
  Serial.println("Eagle Sentinel: sensor-only V1 starting");

  pinMode(VIBRATION_PIN, INPUT_PULLUP);
  pinMode(SOUND_TRIGGER_PIN, INPUT_PULLUP);
  lastVibrationState = digitalRead(VIBRATION_PIN);
  lastSoundState = digitalRead(SOUND_TRIGGER_PIN);

  setupI2sMicrophone();
  setupRadio();
  Serial.println("Ready: vibration, sound trigger, microphone level, and approved RF messages.");
}

void loop() {
  checkDigitalSensors();
  checkMicrophone();
  checkRadio();
  delay(5);
}