Acoustic Drone Detection

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiUdp.h>
#include "driver/i2s.h"

// The laptop joins this Wi-Fi network. Audio is broadcast to UDP port 3333,
// so the receiver can listen on any address assigned by this access point.
struct __attribute__((packed)) AudioPacketHeader {
  char magic[4];       // Always "DAUD".
  uint8_t version;     // Packet format version: 1.
  uint8_t streamId;    // 0 = microphones 1/2, 1 = microphones 3/4.
  uint16_t sequence;   // Increases by one for each packet in a stream.
  uint32_t sampleRate; // Samples per channel per second: 16000.
  uint16_t channels;   // Always 2: left, right, left, right.
  uint16_t frames;     // Frames in this packet: 64.
};


// Forward declarations
static void configureI2s(i2s_port_t port, int bclk, int ws, int dataIn);
static bool readAndSend(i2s_port_t port, uint8_t streamId, uint16_t &sequence);

static const char *AP_NAME = "DroneAudio-ESP32";
static const char *AP_PASSWORD = "droneaudio";
static const uint16_t UDP_PORT = 3333;
static const IPAddress UDP_BROADCAST(192, 168, 4, 255);

static const int SAMPLE_RATE_HZ = 16000;
static const size_t FRAMES_PER_PACKET = 64;
static const size_t STEREO_WORDS = FRAMES_PER_PACKET * 2;

// Pair A: microphones 1 (left) and 2 (right), I2S0.
static const int PAIR_A_BCLK = 25;
static const int PAIR_A_WS = 26;
static const int PAIR_A_DATA = 32;
// Pair B: microphones 3 (left) and 4 (right), I2S1.
static const int PAIR_B_BCLK = 27;
static const int PAIR_B_WS = 14;
static const int PAIR_B_DATA = 33;

WiFiUDP udp;
uint16_t sequenceA = 0;
uint16_t sequenceB = 0;

static void configureI2s(i2s_port_t port, int bclk, int ws, int dataIn) {
  i2s_config_t config = {};
  config.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX);
  config.sample_rate = SAMPLE_RATE_HZ;
  config.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
  config.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT;
  config.communication_format = I2S_COMM_FORMAT_STAND_I2S;
  config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
  config.dma_buf_count = 8;
  config.dma_buf_len = FRAMES_PER_PACKET;
  config.use_apll = false;
  config.tx_desc_auto_clear = false;
  config.fixed_mclk = 0;

  i2s_pin_config_t pins = {};
  pins.bck_io_num = bclk;
  pins.ws_io_num = ws;
  pins.data_out_num = I2S_PIN_NO_CHANGE;
  pins.data_in_num = dataIn;

  ESP_ERROR_CHECK(i2s_driver_install(port, &config, 0, nullptr));
  ESP_ERROR_CHECK(i2s_set_pin(port, &pins));
  ESP_ERROR_CHECK(i2s_zero_dma_buffer(port));
}

static bool readAndSend(i2s_port_t port, uint8_t streamId, uint16_t &sequence) {
  int32_t i2sWords[STEREO_WORDS];
  size_t bytesRead = 0;
  const esp_err_t result = i2s_read(
      port, i2sWords, sizeof(i2sWords), &bytesRead, pdMS_TO_TICKS(100));
  if (result != ESP_OK || bytesRead != sizeof(i2sWords)) {
    return false;
  }

  // INMP441 supplies signed 24-bit samples in 32-bit I2S slots. Send the
  // most significant 16 bits as signed, interleaved stereo PCM.
  int16_t pcm[STEREO_WORDS];
  for (size_t i = 0; i < STEREO_WORDS; ++i) {
    pcm[i] = static_cast<int16_t>(i2sWords[i] >> 16);
  }

  AudioPacketHeader header = {{'D', 'A', 'U', 'D'}, 1, streamId, sequence++,
                              SAMPLE_RATE_HZ, 2, FRAMES_PER_PACKET};
  if (!udp.beginPacket(UDP_BROADCAST, UDP_PORT)) {
    return false;
  }
  udp.write(reinterpret_cast<const uint8_t *>(&header), sizeof(header));
  udp.write(reinterpret_cast<const uint8_t *>(pcm), sizeof(pcm));
  return udp.endPacket() == 1;
}

void setup() {
  Serial.begin(115200);
  delay(300);

  configureI2s(I2S_NUM_0, PAIR_A_BCLK, PAIR_A_WS, PAIR_A_DATA);
  configureI2s(I2S_NUM_1, PAIR_B_BCLK, PAIR_B_WS, PAIR_B_DATA);

  WiFi.mode(WIFI_AP);
  if (!WiFi.softAP(AP_NAME, AP_PASSWORD)) {
    Serial.println("Could not start Wi-Fi access point");
    while (true) {
      delay(1000);
    }
  }
  udp.begin(UDP_PORT);

  Serial.print("Wi-Fi name: ");
  Serial.println(AP_NAME);
  Serial.print("ESP32 address: ");
  Serial.println(WiFi.softAPIP());
  Serial.println("Broadcasting two 16 kHz stereo PCM streams to UDP port 3333");
}

void loop() {
  // The two I2S controllers use separate clocks, so they are not
  // sample-locked; retain each packet sequence number per stereo pair.
  readAndSend(I2S_NUM_0, 0, sequenceA);
  readAndSend(I2S_NUM_1, 1, sequenceB);
}