Pocket All-Day Voice Recorder

#include <Arduino.h>
#include <SPI.h>
#include <SD.h>
#include <driver/i2s.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

constexpr int MIC_BCLK_PIN = 4;
constexpr int MIC_LRCLK_PIN = 5;
constexpr int MIC_DOUT_PIN = 6;
constexpr int SD_CS_PIN = 10;
constexpr int SD_MOSI_PIN = 11;
constexpr int SD_SCK_PIN = 12;
constexpr int SD_MISO_PIN = 13;
constexpr int BUTTON_PIN = 7;
constexpr uint32_t SAMPLE_RATE = 8000;
constexpr uint32_t SEGMENT_SECONDS = 600;
constexpr size_t I2S_BUFFER_BYTES = 1024;
constexpr size_t BLE_CHUNK_BYTES = 180;
constexpr uint8_t BLE_PACKETS_PER_LOOP = 12;

static const char *SERVICE_UUID = "9b7d0001-2d45-4d4c-9f57-2d6d4e6f1001";
static const char *COMMAND_UUID = "9b7d0002-2d45-4d4c-9f57-2d6d4e6f1001";
static const char *STATUS_UUID = "9b7d0003-2d45-4d4c-9f57-2d6d4e6f1001";
static const char *DATA_UUID = "9b7d0004-2d45-4d4c-9f57-2d6d4e6f1001";

struct __attribute__((packed)) WavHeader {
  char riff[4];
  uint32_t fileSizeMinus8;
  char wave[4];
  char fmt[4];
  uint32_t fmtSize;
  uint16_t audioFormat;
  uint16_t channels;
  uint32_t sampleRate;
  uint32_t byteRate;
  uint16_t blockAlign;
  uint16_t bitsPerSample;
  char data[4];
  uint32_t dataSize;
};

BLECharacteristic *statusCharacteristic = nullptr;
BLECharacteristic *dataCharacteristic = nullptr;
File recordingFile;
File transferFile;
char currentFileName[20] = {0};
uint32_t currentDataBytes = 0;
uint32_t segmentStartedMs = 0;
uint32_t nextFileNumber = 0;
uint32_t transferSequence = 0;
bool recording = false;
bool transferActive = false;
bool transferRequested = false;
bool buttonWasDown = false;

void sendStatus(const String &message) {
  if (statusCharacteristic != nullptr) {
    statusCharacteristic->setValue(message.c_str());
    statusCharacteristic->notify();
  }
}

void writeWavHeader(File &file, uint32_t dataBytes) {
  WavHeader header = {
    {'R', 'I', 'F', 'F'},
    static_cast<uint32_t>(36 + dataBytes),
    {'W', 'A', 'V', 'E'},
    {'f', 'm', 't', ' '},
    16,
    1,
    1,
    SAMPLE_RATE,
    SAMPLE_RATE * 2,
    2,
    16,
    {'d', 'a', 't', 'a'},
    dataBytes
  };
  file.seek(0);
  file.write(reinterpret_cast<const uint8_t *>(&header), sizeof(header));
}

bool openNewSegment() {
  if (recordingFile) {
    writeWavHeader(recordingFile, currentDataBytes);
    recordingFile.close();
  }

  do {
    snprintf(currentFileName, sizeof(currentFileName), "/REC%05lu.WAV", static_cast<unsigned long>(nextFileNumber++));
  } while (SD.exists(currentFileName));

  recordingFile = SD.open(currentFileName, FILE_WRITE);
  if (!recordingFile) {
    sendStatus("ERROR: cannot create recording");
    return false;
  }
  currentDataBytes = 0;
  writeWavHeader(recordingFile, 0);
  segmentStartedMs = millis();
  sendStatus(String("RECORDING:") + currentFileName);
  return true;
}

void stopRecording() {
  if (recordingFile) {
    writeWavHeader(recordingFile, currentDataBytes);
    recordingFile.close();
  }
  recording = false;
  sendStatus("RECORDING_STOPPED");
}

void configureI2S() {
  i2s_config_t config = {};
  config.mode = static_cast<i2s_mode_t>(I2S_MODE_MASTER | I2S_MODE_RX);
  config.sample_rate = SAMPLE_RATE;
  config.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
  config.channel_format = I2S_CHANNEL_FMT_ONLY_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 = 256;
  config.use_apll = false;
  config.tx_desc_auto_clear = false;
  config.fixed_mclk = 0;
  i2s_driver_install(I2S_NUM_0, &config, 0, nullptr);

  i2s_pin_config_t pins = {};
  pins.bck_io_num = MIC_BCLK_PIN;
  pins.ws_io_num = MIC_LRCLK_PIN;
  pins.data_out_num = I2S_PIN_NO_CHANGE;
  pins.data_in_num = MIC_DOUT_PIN;
  i2s_set_pin(I2S_NUM_0, &pins);
  i2s_zero_dma_buffer(I2S_NUM_0);
}

String findNextCompletedFile() {
  File root = SD.open("/");
  if (!root) return String();
  File candidate;
  while (true) {
    File entry = root.openNextFile();
    if (!entry) break;
    String name = String(entry.name());
    bool usable = !entry.isDirectory() && name.startsWith("/REC") && name.endsWith(".WAV") && name != String(currentFileName);
    entry.close();
    if (usable) {
      root.close();
      return name;
    }
  }
  root.close();
  return String();
}

void beginTransfer() {
  if (transferActive) return;
  String path = findNextCompletedFile();
  if (path.length() == 0) {
    sendStatus("NO_COMPLETED_FILE");
    return;
  }
  transferFile = SD.open(path, FILE_READ);
  if (!transferFile) {
    sendStatus("ERROR: cannot open file");
    return;
  }
  transferSequence = 0;
  transferActive = true;
  sendStatus(String("BEGIN:") + path + ":" + String(transferFile.size()));
}

void serviceTransfer() {
  if (transferRequested) {
    transferRequested = false;
    beginTransfer();
  }
  if (!transferActive || !transferFile) return;

  uint8_t packet[BLE_CHUNK_BYTES + 4];
  for (uint8_t n = 0; n < BLE_PACKETS_PER_LOOP && transferActive; ++n) {
    size_t bytesRead = transferFile.read(packet + 4, BLE_CHUNK_BYTES);
    if (bytesRead == 0) {
      transferFile.close();
      transferActive = false;
      sendStatus("END");
      break;
    }
    packet[0] = static_cast<uint8_t>(transferSequence & 0xFF);
    packet[1] = static_cast<uint8_t>((transferSequence >> 8) & 0xFF);
    packet[2] = static_cast<uint8_t>((transferSequence >> 16) & 0xFF);
    packet[3] = static_cast<uint8_t>((transferSequence >> 24) & 0xFF);
    dataCharacteristic->setValue(packet, bytesRead + 4);
    dataCharacteristic->notify();
    ++transferSequence;
  }
}

class RecorderCommandCallbacks : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *characteristic) override {
    String value = characteristic->getValue();
    if (value == "NEXT") {
      transferRequested = true;
    } else if (value == "STATUS") {
      sendStatus(recording ? "RECORDING" : "PAUSED");
    }
  }
};

void configureBle() {
  BLEDevice::init("Pocket Recorder");
  BLEServer *server = BLEDevice::createServer();
  BLEService *service = server->createService(SERVICE_UUID);
  BLECharacteristic *commandCharacteristic = service->createCharacteristic(
    COMMAND_UUID, BLECharacteristic::PROPERTY_WRITE);
  commandCharacteristic->setCallbacks(new RecorderCommandCallbacks());
  statusCharacteristic = service->createCharacteristic(
    STATUS_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
  dataCharacteristic = service->createCharacteristic(
    DATA_UUID, BLECharacteristic::PROPERTY_NOTIFY);
  statusCharacteristic->addDescriptor(new BLE2902());
  dataCharacteristic->addDescriptor(new BLE2902());
  statusCharacteristic->setValue("READY");
  service->start();
  BLEAdvertising *advertising = BLEDevice::getAdvertising();
  advertising->addServiceUUID(SERVICE_UUID);
  advertising->setScanResponse(true);
  advertising->start();
}

void captureAudio() {
  int32_t rawSamples[I2S_BUFFER_BYTES / sizeof(int32_t)];
  size_t bytesRead = 0;
  esp_err_t result = i2s_read(I2S_NUM_0, rawSamples, sizeof(rawSamples), &bytesRead, portMAX_DELAY);
  if (result != ESP_OK || bytesRead == 0 || !recordingFile) return;

  const size_t sampleCount = bytesRead / sizeof(int32_t);
  int16_t monoSamples[I2S_BUFFER_BYTES / sizeof(int32_t)];
  for (size_t i = 0; i < sampleCount; ++i) {
    int32_t scaled = rawSamples[i] >> 14;
    if (scaled > 32767) scaled = 32767;
    if (scaled < -32768) scaled = -32768;
    monoSamples[i] = static_cast<int16_t>(scaled);
  }
  size_t written = recordingFile.write(reinterpret_cast<const uint8_t *>(monoSamples), sampleCount * sizeof(int16_t));
  currentDataBytes += written;

  if (millis() - segmentStartedMs >= SEGMENT_SECONDS * 1000UL) {
    openNewSegment();
  }
}

void serviceButton() {
  bool buttonDown = digitalRead(BUTTON_PIN) == LOW;
  if (buttonDown && !buttonWasDown) {
    if (recording) {
      stopRecording();
    } else {
      recording = openNewSegment();
    }
  }
  buttonWasDown = buttonDown;
}

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(115200);
  SPI.begin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN, SD_CS_PIN);
  if (!SD.begin(SD_CS_PIN, SPI)) {
    Serial.println("microSD card failed");
    return;
  }
  configureI2S();
  configureBle();
  recording = openNewSegment();
}

void loop() {
  serviceButton();
  if (recording) {
    captureAudio();
  }
  serviceTransfer();
  delay(1);
}