ESP32 Noise Signal Generator

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_MCP4725.h>

// Low-level laboratory noise source: no RF power stage and no antenna.

// Hoisted type definitions
enum NoiseMode : uint8_t { WHITE = 0, PINKISH = 1, BURST = 2 };


// Forward declarations
uint32_t nextRandom();
int16_t makeSample();
void IRAM_ATTR onSampleTimer();
void dacWriterTask(void *);
void printStatus();
void processCommand(String command);

constexpr uint8_t I2C_SDA_PIN = 21;
constexpr uint8_t I2C_SCL_PIN = 22;
constexpr uint8_t AMPLITUDE_POT_PIN = 34;
constexpr uint8_t MCP4725_ADDRESS = 0x60;
constexpr uint32_t SAMPLE_RATE_HZ = 4000;
constexpr uint32_t TIMER_TICK_US = 1000000UL / SAMPLE_RATE_HZ;

Adafruit_MCP4725 dac;
hw_timer_t *sampleTimer = nullptr;
TaskHandle_t dacTaskHandle = nullptr;

portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
volatile bool generatorEnabled = true;
volatile bool timerTick = false;


volatile NoiseMode mode = WHITE;
volatile uint16_t manualAmplitude = 0;  // 0 means use the front-panel potentiometer.
uint32_t rngState = 0xA5C35A17UL;
int32_t pinkState = 0;
uint32_t lastControlReadMs = 0;
uint16_t potAmplitude = 3072;

uint32_t nextRandom() {
  rngState ^= rngState << 13;
  rngState ^= rngState >> 17;
  rngState ^= rngState << 5;
  return rngState;
}

int16_t makeSample() {
  int16_t white = static_cast<int16_t>((nextRandom() >> 16) & 0xFFFF) - 32768;

  if (mode == WHITE) return white;

  if (mode == PINKISH) {
    // One-pole low-pass of white noise: visibly more low-frequency content.
    pinkState += (static_cast<int32_t>(white) - pinkState) >> 3;
    return static_cast<int16_t>(constrain(pinkState, -32768L, 32767L));
  }

  // A repeating 250 ms ON / 250 ms OFF noise burst for trigger tests.
  uint32_t phase = (millis() / 250UL) & 1U;
  return phase == 0 ? white : 0;
}

void IRAM_ATTR onSampleTimer() {
  BaseType_t higherPriorityTaskWoken = pdFALSE;
  timerTick = true;
  vTaskNotifyGiveFromISR(dacTaskHandle, &higherPriorityTaskWoken);
  if (higherPriorityTaskWoken) portYIELD_FROM_ISR();
}

void dacWriterTask(void *) {
  for (;;) {
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    if (!generatorEnabled) {
      dac.setVoltage(2048, false);
      continue;
    }

    uint16_t amplitude = manualAmplitude ? manualAmplitude : potAmplitude;
    int32_t signedValue = makeSample();
    int32_t centeredCode = 2048 + ((signedValue * amplitude) >> 16);
    uint16_t code = static_cast<uint16_t>(constrain(centeredCode, 0L, 4095L));
    dac.setVoltage(code, false);
  }
}

void printStatus() {
  const char *names[] = {"white", "pinkish", "burst"};
  uint16_t amplitude = manualAmplitude ? manualAmplitude : potAmplitude;
  Serial.println();
  Serial.println("Noise generator status");
  Serial.printf("mode: %s\n", names[mode]);
  Serial.printf("sample rate: %lu Hz\n", static_cast<unsigned long>(SAMPLE_RATE_HZ));
  Serial.printf("amplitude: %u / 4095 (%s)\n", amplitude,
                manualAmplitude ? "Serial setting" : "front-panel potentiometer");
  Serial.printf("output: %s\n", generatorEnabled ? "enabled" : "muted at DAC midpoint");
  Serial.println("Commands: help | status | mode white|pink|burst | amp 0..4095 | pot | on | off");
}

void processCommand(String command) {
  command.trim();
  command.toLowerCase();
  if (command == "help") {
    Serial.println("help | status | mode white|pink|burst | amp 0..4095 | pot | on | off");
  } else if (command == "status") {
    printStatus();
  } else if (command == "mode white") {
    mode = WHITE; Serial.println("Mode set to white.");
  } else if (command == "mode pink") {
    mode = PINKISH; Serial.println("Mode set to pinkish.");
  } else if (command == "mode burst") {
    mode = BURST; Serial.println("Mode set to burst.");
  } else if (command == "pot") {
    manualAmplitude = 0; Serial.println("Amplitude now follows the potentiometer.");
  } else if (command == "on") {
    generatorEnabled = true; Serial.println("Output enabled.");
  } else if (command == "off") {
    generatorEnabled = false; Serial.println("Output muted.");
  } else if (command.startsWith("amp ")) {
    long value = command.substring(4).toInt();
    if (value >= 0 && value <= 4095) {
      manualAmplitude = static_cast<uint16_t>(value);
      Serial.printf("Amplitude set to %ld / 4095.\n", value);
    } else {
      Serial.println("Amplitude must be from 0 to 4095.");
    }
  } else if (command.length()) {
    Serial.println("Unknown command. Type help.");
  }
}

void setup() {
  Serial.begin(115200);
  delay(300);
  analogReadResolution(12);
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN, 400000);

  if (!dac.begin(MCP4725_ADDRESS, &Wire)) {
    Serial.println("MCP4725 was not found at I2C address 0x60. Check 3.3V, GND, SDA and SCL.");
    while (true) delay(1000);
  }
  dac.setVoltage(2048, false);

  xTaskCreatePinnedToCore(dacWriterTask, "dacWriter", 4096, nullptr, 3, &dacTaskHandle, 1);
  sampleTimer = timerBegin(0, 80, true);  // 80 MHz / 80 = 1 MHz timer tick.
  timerAttachInterrupt(sampleTimer, &onSampleTimer, true);
  timerAlarmWrite(sampleTimer, TIMER_TICK_US, true);
  timerAlarmEnable(sampleTimer);

  Serial.println("ESP32 low-level noise generator ready.");
  printStatus();
}

void loop() {
  if (millis() - lastControlReadMs >= 40) {
    lastControlReadMs = millis();
    // ADC1/GPIO34 is safe while Wi-Fi remains unused; average four readings.
    uint32_t total = 0;
    for (uint8_t i = 0; i < 4; ++i) total += analogRead(AMPLITUDE_POT_PIN);
    potAmplitude = static_cast<uint16_t>(total / 4);
  }

  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    processCommand(command);
  }
}