Sound-reactive LED strip on an ESP32-C3

// Sound-reactive LED strip: a KY-038 microphone and sixteen WS2812Bs.
//
// Wiring:
//   KY-038      AO -> GPIO 4   DO -> GPIO 3   VCC -> 3V3   GND -> GND
//   WS2812B     DIN -> GPIO 5  VDD -> 5V      VSS -> GND
//
// The strip is a VU meter: the louder the room, the further up the strip it
// lights, green at the bottom through yellow to red at the top, with a peak
// dot that hangs for a moment and then falls. A loud bang (a clap, a kick
// drum) trips the module's comparator on DO, and every one of those shifts
// the colors round the wheel, so the strip changes with the beat.
//
// # Reading a microphone with no amplifier
//
// The KY-038 has no amplifier: AO is the capsule's own few millivolts riding
// on half the supply. So the sketch does not read the level, it reads how far
// the signal swings. Every frame it takes a burst of samples and keeps the
// highest and the lowest; the difference, peak to peak, is the loudness. The
// ADC here is twelve bits on 3.3 V, about 0.8 mV a step, which is just fine
// enough to see a loud room move it. Quiet talk does not.
//
// In the simulator, set the room's sound level on the sensor, or press its
// clap button.

#include "mokxi_ws2812.h"

const uint8_t MIC_PIN = 4;   // ADC1 channel 4
const uint8_t BEAT_PIN = 3;  // the comparator output
const uint8_t DIN_PIN = 5;
const uint16_t LEDS = 16;

uint8_t pixels[LEDS * 3];
Ws2812 strip(DIN_PIN, pixels, LEDS);

// Peak-to-peak counts for each bar: roughly even steps of loudness, since
// your ear hears ratios, not differences.
const uint16_t BAR_AT[LEDS] = {4, 6, 9, 13, 18, 25, 34, 46, 62, 82, 108, 140, 180, 230, 290, 360};

const uint8_t BRIGHT = 60;
const uint32_t FRAME_MS = 25;

uint8_t level = 0;      // bars lit, after smoothing
uint8_t peak = 0;       // where the peak dot sits
uint32_t peakAt = 0;    // when it got there
uint16_t hueShift = 0;  // moves round the wheel on every beat
uint8_t flash = 0;      // brightness boost after a beat, fading out
bool beatWas = false;
uint32_t beatGuardUntil = 0;
uint32_t reportAt = 0;

/** How far the microphone swings over a burst of samples. */
static uint16_t loudness()
{
  int lo = 4095, hi = 0;
  for (uint8_t i = 0; i < 120; i++) {
    int v = analogRead(MIC_PIN);
    if (v < lo) lo = v;
    if (v > hi) hi = v;
    delayMicroseconds(120);
  }
  return (uint16_t)(hi - lo);
}

static uint8_t barsFor(uint16_t p2p)
{
  uint8_t n = 0;
  while (n < LEDS && p2p >= BAR_AT[n]) {
    n++;
  }
  return n;
}

void setup()
{
  Serial.begin(115200);
  pinMode(BEAT_PIN, INPUT);
  strip.begin();
  strip.clear();
  strip.show();
  Serial.println("Sound strip: make some noise");
}

void loop()
{
  uint32_t frameStart = millis();
  uint16_t p2p = loudness();
  uint8_t bars = barsFor(p2p);

  // Jump up at once, fall back a bar at a time: that is what makes it dance.
  if (bars > level) {
    level = bars;
  } else if (level > 0) {
    level--;
  }
  if (level >= peak) {
    peak = level;
    peakAt = frameStart;
  } else if (frameStart - peakAt > 400 && peak > 0) {
    peak--;  // the dot hangs for 400 ms, then drops
    peakAt = frameStart - 340;
  }

  // DO is a burst of pulses on a loud sound, not one clean level, so take
  // the first edge and ignore the rest for a moment.
  bool beat = digitalRead(BEAT_PIN) == HIGH;
  if (beat && !beatWas && (int32_t)(frameStart - beatGuardUntil) >= 0) {
    hueShift = (uint16_t)((hueShift + 256) % 1536);
    flash = 120;
    beatGuardUntil = frameStart + 150;
    Serial.println("Beat!");
  }
  beatWas = beat;

  uint8_t bright = (uint8_t)(BRIGHT + flash > 255 ? 255 : BRIGHT + flash);
  for (uint16_t i = 0; i < LEDS; i++) {
    uint8_t r = 0, g = 0, b = 0;
    if (i < level || (i == peak && peak > 0)) {
      // green at the bottom, through yellow, to red at the top, turned by beats
      uint16_t hue = (uint16_t)((512 - i * 512 / (LEDS - 1) + hueShift) % 1536);
      ws2812_wheel(hue, &r, &g, &b);
      if (i == peak && i >= level) {
        r = g = b = 255;  // the peak dot is white
      }
    }
    strip.setPixel(i, ws2812_scale(r, bright), ws2812_scale(g, bright), ws2812_scale(b, bright));
  }
  strip.show();
  if (flash > 0) {
    flash = (uint8_t)(flash > 15 ? flash - 15 : 0);
  }

  if (frameStart - reportAt >= 1000) {
    reportAt = frameStart;
    Serial.print("level ");
    Serial.print(level);
    Serial.print("/16, swing ");
    Serial.print(p2p);
    Serial.println(" counts");
  }

  uint32_t spent = millis() - frameStart;
  if (spent < FRAME_MS) {
    delay(FRAME_MS - spent);
  }
}