loudness_gauge.tc

// loudness_gauge.tc — plugin-INDEPENDENT sound I/O demo for the Waveshare ESP32-P4 10.1".
//
//   OUTPUT: on boot, init the ES8311 DAC over I2C and play an intro .wav (i2sBegin TX).
//   INPUT : then init the ES7210 4-mic ADC over I2C and show a live loudness gauge
//           (arc dial + % + peak + VU bar) on the LVGL display (i2sMicBegin RX).
//
// No audio plugin needed — both codecs are driven entirely from this script via the
// i2c* syscalls. Board: I2S MCLK=13 BCLK=12 WS=10 DOUT=9(spkr) DIN=11(mic) ; ES8311
// @0x18, ES7210 @0x40 ; display 800x1280. Needs USE_TINYC_LVGL firmware, ABI >= 7.
//
// The intro .wav MUST be 16 kHz mono 16-bit PCM (the ES8311 here is clocked for 16 kHz).
//   ffmpeg -i in.wav -ar 16000 -ac 1 -c:a pcm_s16le /intro.wav
//
// ── TWO BUILD TARGETS ───────────────────────────────────────────────────────
//   DEFAULT (no define): plugin-INDEPENDENT — this script drives ES8311 + ES7210
//     itself via i2c*/i2sMic. Use on any board WITHOUT the audio BinPlugin.
//   -DPLUGIN_MIC: the audio BinPlugin (xdrv_42_i2s) already owns the full-duplex
//     I2S — its native i2sMic would conflict, so instead read the mic level via
//     pluginQuery(42,0,10) and play the intro via audioPlay. Use on the P4 display
//     where the plugin is loaded + inited (iniz). The ES7210/ES8311 I2C init and
//     the WAV streamer are compiled OUT — the plugin does all of that.
//     Enable by compiling with -DPLUGIN_MIC, or uncomment the next line:
// // @defines: -DPLUGIN_MIC

#define INTRO_WAV  "/doorbell16.wav"   // 16 kHz → no upsampling (8 kHz Startup.wav's upsample
                                       // loop blows the 200k-instruction/call limit in main)
#define MIC_MCLK   13
#define MIC_BCLK   12
#define MIC_WS     10
#define MIC_DIN    11
#define DAC_DOUT   9
#define MIC_RATE   16000
#define PA_EN      53          // speaker power-amp enable (Waveshare P4: GPIO53)
#define OUTPUT     0x03

#define ES7210_ADDR 0x40
#define ES8311_ADDR 0x18
#define ES_BUS      0           // I2C bus the codecs are on

#define AL_TOP_MID  2
#define COL_BG      0x0e1016
#define COL_GREEN   0x3ddc84
#define COL_YELLOW  0xffcc44
#define COL_RED     0xff5555
#define COL_DIM     0x7a8aa0

// (PLUGIN_MIC only) the plugin returns a RAW peak |sample| and its analog mic gain is
// modest, so the signal sits low (e.g. ~40 quiet, a few hundred on speech). Map a
// noise-floor..full-scale window onto 0..100% so the dial actually moves. Tune to taste:
// lower MIC_FS = more sensitive; raise MIC_FLOOR if a silent room still shows a few %.
#define MIC_FLOOR   40         // raw level treated as 0%
#define MIC_FS      2500       // DEFAULT raw level for 100% (lower = more sensitive).
                               // Tune LIVE with no rebuild: send "MIC <n>" (e.g. MIC 4000).

int micok = 0;
int level = 0;
int peak  = 0;
int g_pct = 0;                          // last gauge percent (echoed in the MIC debug line)
int g_fs  = MIC_FS;                     // (PLUGIN_MIC) runtime full-scale; set live via "MIC <n>"
int arc; int lblPct; int lblPeak; int lblTitle; int bar;

#ifdef PLUGIN_MIC
char qbuf[16];                          // pluginQuery dst for the mic peak string
#else
int wav_channels = 1; int wav_rate = 16000; int wav_bits = 16; int wav_data_size = 0;
int pcm[512];                           // WAV streaming buffer (native intro only)
#endif
int dbg_fk = -9; int dbg_pr = -9; int dbg_rate = 0; int dbg_bits = 0; int dbg_ib = -9; int dbg_fr = 0; int dbg_path = -1; int dbg_stage = -1;

#ifndef PLUGIN_MIC   // ── native codec drivers + WAV streamer (plugin build drops all of this) ──
// ───────── ES7210 mic ADC over I2C (port of pes7210_codec_init) ─────────
void aw(int reg, int val) { i2cWrite8(ES7210_ADDR, reg, val, ES_BUS); }
int  ar_(int reg)         { return i2cRead8(ES7210_ADDR, reg, ES_BUS); }
void aupd(int reg, int mask, int val) { int v = ar_(reg); v = (v & (255 - mask)) | (mask & val); aw(reg, v); }
void a_mic_all() {
    int i;
    for (i = 0; i < 4; i = i + 1) { aupd(0x43 + i, 0x10, 0x00); }
    aw(0x4B, 0xff); aw(0x4C, 0xff);
    aupd(0x01, 0x0b, 0x00); aw(0x4B, 0x00); aupd(0x43, 0x10, 0x10);
    aupd(0x01, 0x0b, 0x00); aw(0x4B, 0x00); aupd(0x44, 0x10, 0x10);
    aupd(0x01, 0x15, 0x00); aw(0x4C, 0x00); aupd(0x45, 0x10, 0x10);
    aupd(0x01, 0x15, 0x00); aw(0x4C, 0x00); aupd(0x46, 0x10, 0x10);
}
void es7210_init() {
    aw(0x00, 0xff); aw(0x00, 0x41); aw(0x01, 0x1f);
    aw(0x09, 0x30); aw(0x0A, 0x30); aw(0x40, 0xC3);
    aw(0x41, 0x70); aw(0x42, 0x70); aw(0x07, 0x20);
    aw(0x02, 0xC1); aw(0x07, 0x20); aw(0x04, 0x01); aw(0x05, 0x00);
    a_mic_all();
    int iface = ar_(0x11) & 0x1f; aw(0x11, iface | 0x60);
    iface = ar_(0x11) & 0xfc;     aw(0x11, iface);
    aw(0x12, 0x00);
    aupd(0x43, 0x0f, 14); aupd(0x44, 0x0f, 14);
    aupd(0x45, 0x0f, 0);  aupd(0x46, 0x0f, 0);
    int regv = ar_(0x01); aw(0x01, regv);
    aw(0x06, 0x00);
    aw(0x47, 0x00); aw(0x48, 0x00); aw(0x49, 0x00); aw(0x4A, 0x00);
    a_mic_all();
}

// ───────── ES8311 DAC over I2C (port of pes8311_codec_init, slave 16-bit 16 kHz) ─────────
void dw(int reg, int val) { i2cWrite8(ES8311_ADDR, reg, val, ES_BUS); }
int  dr(int reg)          { return i2cRead8(ES8311_ADDR, reg, ES_BUS); }
void es8311_init() {
    int v;
    dw(0x01, 0x30); dw(0x02, 0x00); dw(0x03, 0x10); dw(0x16, 0x24);
    dw(0x04, 0x10); dw(0x05, 0x00); dw(0x0B, 0x00); dw(0x0C, 0x00);
    dw(0x10, 0x1F); dw(0x11, 0x7F); dw(0x00, 0x80);
    v = dr(0x00) & 0xBF; dw(0x00, v);                    // slave
    dw(0x01, 0x3F);
    v = dr(0x01) & 0x7F; dw(0x01, v);                    // mclk from pin
    v = dr(0x02) & 0x07; dw(0x02, v);                    // pre_div/multi = 1
    dw(0x05, 0x00);                                       // adc/dac div = 1
    v = (dr(0x03) & 0x80) | 0x10; dw(0x03, v);           // adc_osr
    v = (dr(0x04) & 0x80) | 0x10; dw(0x04, v);           // dac_osr
    v = dr(0x07) & 0xC0; dw(0x07, v);                    // lrck_h
    dw(0x08, 0xff);                                       // lrck_l
    v = (dr(0x06) & 0xE0) | 3; dw(0x06, v);             // bclk_div = 4
    v = dr(0x01) & (255 - 0x40); dw(0x01, v);            // mclk not inverted
    v = dr(0x06) & (255 - 0x20); dw(0x06, v);            // sclk not inverted
    dw(0x13, 0x10); dw(0x1B, 0x0A); dw(0x1C, 0x6A);
    v = dr(0x09) | 0x0c; dw(0x09, v);                    // 16-bit
    v = dr(0x0A) | 0x0c; dw(0x0A, v);
    v = dr(0x09) & 0xFC; dw(0x09, v);                    // I2S normal
    v = dr(0x0A) & 0xFC; dw(0x0A, v);
    v = dr(0x09) & 0xBF; v = v & (255 - 0x40); dw(0x09, v);  // enable DAC serial in
    v = dr(0x0A) & 0xBF; v = v & (255 - 0x40); dw(0x0A, v);
    dw(0x17, 0xBF); dw(0x0E, 0x02); dw(0x12, 0x00); dw(0x14, 0x1A);
    v = dr(0x14) & (255 - 0x40); dw(0x14, v);            // IS_DMIC = 0
    dw(0x0D, 0x01); dw(0x15, 0x40); dw(0x37, 0x48); dw(0x45, 0x00);
    v = dr(0x31) & 0x9f; dw(0x31, v);                    // unmute
    dw(0x12, 0x00);
}
void es8311_volume(int vol) {            // 0..100, perceptual
    if (vol <= 0) { dw(0x32, 0); return; }
    if (vol > 100) { vol = 100; }
    // reg 0x32 is ~0.5 dB/step (log) → linear-in-reg = perceptually even. Use a usable band
    // (reg ~110..195 ≈ -40..+2 dB); a raw 0-255 map left the bottom half inaudible.
    dw(0x32, 110 + (vol * 85) / 100);
}

// ───────── WAV parse + play (16-bit, walks chunks; from wav_player) ─────────
int parse_wav(int f) {
    char hdr[12]; int n = fileRead(f, hdr, 12);
    if (n < 12) { return -1; }
    if (hdr[0] != 'R' || hdr[1] != 'I' || hdr[2] != 'F' || hdr[3] != 'F') { return -1; }
    int got_fmt = 0; int got_data = 0;
    char ck[8]; char fmt[16]; char skip[64];
    while (got_fmt == 0 || got_data == 0) {
        n = fileRead(f, ck, 8);
        if (n < 8) { return -1; }
        int csz = (ck[4]&255) | ((ck[5]&255)<<8) | ((ck[6]&255)<<16) | ((ck[7]&255)<<24);
        if (ck[0]=='f' && ck[1]=='m' && ck[2]=='t' && ck[3]==' ') {
            n = fileRead(f, fmt, 16);
            if (n < 16) { return -1; }
            wav_channels = (fmt[2]&255) | ((fmt[3]&255)<<8);
            wav_rate = (fmt[4]&255) | ((fmt[5]&255)<<8) | ((fmt[6]&255)<<16) | ((fmt[7]&255)<<24);
            wav_bits = (fmt[14]&255) | ((fmt[15]&255)<<8);
            got_fmt = 1;
            int rem = csz - 16;
            while (rem > 0) { int rd = 64; if (rd > rem) { rd = rem; } fileRead(f, skip, rd); rem = rem - rd; }
        } else if (ck[0]=='d' && ck[1]=='a' && ck[2]=='t' && ck[3]=='a') {
            wav_data_size = csz; got_data = 1;
        } else {
            int rem = csz;
            while (rem > 0) { int rd = 64; if (rd > rem) { rd = rem; } fileRead(f, skip, rd); rem = rem - rd; }
        }
    }
    return 0;
}
void play_wav(char path[]) {
    char p[96];
    int f = fileOpen(path, "r"); dbg_path = 0;          // default route (ufsp)
    if (f < 0) { sprintf(p, "/ffs%s", path); f = fileOpen(p, "r"); dbg_path = 1; }    // flash FS
    if (f < 0) { sprintf(p, "/sdfs%s", path); f = fileOpen(p, "r"); dbg_path = 2; }   // SD FS (explicit)
    dbg_fk = f;
    if (f < 0) { addLog("intro: %s not found (all FS)", path); return; }
    int pr = parse_wav(f); dbg_pr = pr; dbg_rate = wav_rate; dbg_bits = wav_bits;
    if (pr < 0 || wav_bits != 16) { addLog("intro: bad/!16-bit wav"); fileClose(f); return; }
    // ES8311 is clocked at MIC_RATE; upsample (sample-repeat) lower-rate WAVs so
    // they play at the right pitch (e.g. 8 kHz -> ratio 2).
    int ratio = MIC_RATE / wav_rate;
    if (ratio < 1) { ratio = 1; }
    if (ratio > 4) { ratio = 4; }
    dbg_ib = i2sBegin(MIC_MCLK, MIC_BCLK, MIC_WS, DAC_DOUT, MIC_RATE);
    if (dbg_ib < 0) { addLog("intro: i2sBegin failed"); fileClose(f); return; }
    if (pinFree(PA_EN)) { pinMode(PA_EN, OUTPUT); }
    digitalWrite(PA_EN, 1);              // enable the speaker power amp for the intro
    int remaining = wav_data_size / (wav_channels * 2);
    int read_chunk = 128 / ratio;        // small chunks keep the P4 I2S DMA fed (512/256 scrambled)
    if (read_chunk < 1) { read_chunk = 1; }
    while (remaining > 0) {
        int chunk = read_chunk;
        if (chunk > remaining) { chunk = remaining; }
        int frames = fileReadPCM16(f, pcm, chunk, wav_channels);
        if (frames <= 0) { break; }
        if (ratio > 1) {                          // expand in place (backwards)
            int i;
            for (i = frames - 1; i >= 0; i = i - 1) {
                int j;
                for (j = 0; j < ratio; j = j + 1) { pcm[i * ratio + j] = pcm[i]; }
            }
            frames = frames * ratio;
        }
        int w = i2sWrite(pcm, frames); dbg_fr = dbg_fr + w;
        if (w < frames) { break; }   // TX stalled/timeout — stop, don't loop on noise
        remaining = remaining - chunk;
    }
    fileClose(f);
    delay(400);                          // drain the last DMA buffer before stopping
    i2sStop();
    digitalWrite(PA_EN, 0);              // amp off after the intro (mic gauge doesn't need it)
    addLog("intro: played");
}
#endif   // !PLUGIN_MIC (native codec + WAV block)

// ───────── loudness meter ─────────
int isqrt(int n) {
    if (n <= 0) { return 0; }
    int x = n; int y = (x + 1) / 2;
    while (y < x) { x = y; y = (x + n / x) / 2; }
    return x;
}
int pct_of(int rms) { int p = (isqrt(rms) * 100) / 181; if (p > 100) { p = 100; } return p; }

void Every100ms() {
    if (!micok) { return; }
#ifdef PLUGIN_MIC
    int n = pluginQuery(qbuf, 42, 0, 10);   // 10 = I2S_Q_MICLEVEL: peak |sample| 0..32767
    int v = (n > 0) ? atoi(qbuf) : -1;
#else
    int v = i2sMicLevel();                  // native RMS-ish level 0..32767
#endif
    if (v < 0) { return; }
    level = v;
    if (v > peak) { peak = v; } else { peak = (peak * 9) / 10; }
#ifdef PLUGIN_MIC
    int p  = (level > MIC_FLOOR ? (level - MIC_FLOOR) * 100 / g_fs : 0); if (p  > 100) { p  = 100; }
    int pk = (peak  > MIC_FLOOR ? (peak  - MIC_FLOOR) * 100 / g_fs : 0); if (pk > 100) { pk = 100; }
#else
    int p  = pct_of(level);              // native i2sMicLevel = RMS, perceptual sqrt curve
    int pk = pct_of(peak);
#endif
    g_pct = p;
    lvglSetValue(arc, p, 0);
    lvglSetValue(bar, p, 0);
    char b[24];
    sprintf(b, "%d%%", p);        lvglSetText(lblPct, b);
    sprintf(b, "peak  %d%%", pk); lvglSetText(lblPeak, b);
    int col = COL_GREEN;
    if (p >= 85) { col = COL_RED; } else if (p >= 60) { col = COL_YELLOW; }
    lvglSetTextColor(lblPct, col);
}

void Command(char cmd[]) {
#ifdef PLUGIN_MIC
    int f = atoi(cmd);                          // "MIC <n>" sets full-scale live (atoi skips spaces)
    if (f >= 50 && f <= 32000) { g_fs = f; }
#endif
    char resp[120];
    sprintf(resp, "stage=%d rms=%d pct=%d%% fs=%d cmd=[%s]",
        dbg_stage, level, g_pct, g_fs, cmd);
    responseCmnd(resp);
}

void build_gauge() {
    lvglInit(); lvglClean(0); lvglSetBgColor(0, COL_BG);
    lblTitle = lvglLabel(0); lvglSetText(lblTitle, "AUDIO  LEVEL");
    lvglSetFont(lblTitle, 28); lvglSetTextColor(lblTitle, COL_DIM); lvglAlign(lblTitle, AL_TOP_MID, 0, 150);
    arc = lvglArc(0); lvglSetSize(arc, 600, 600); lvglSetRange(arc, 0, 100); lvglSetValue(arc, 0, 0);
    lvglAlign(arc, AL_TOP_MID, 0, 300);
    lblPct = lvglLabel(0); lvglSetText(lblPct, "0%"); lvglSetFont(lblPct, 28);
    lvglSetTextColor(lblPct, COL_GREEN); lvglAlign(lblPct, AL_TOP_MID, 0, 580);
    lblPeak = lvglLabel(0); lvglSetText(lblPeak, "peak  0%"); lvglSetTextColor(lblPeak, COL_DIM);
    lvglAlign(lblPeak, AL_TOP_MID, 0, 940);
    bar = lvglBar(0); lvglSetSize(bar, 640, 44); lvglSetRange(bar, 0, 100); lvglSetValue(bar, 0, 0);
    lvglAlign(bar, AL_TOP_MID, 0, 1030);
}

int main() {
    addCommand("MIC");                   // register FIRST so MIC is queryable even if main aborts
    dbg_stage = 0;
#ifndef PLUGIN_MIC
    i2sMicStop();                        // release any I2S RX/TX held by a previous run
    i2sStop();                           // (handles are global → the intro TX needs the pins free)
#endif

    // Intro startup sound FIRST — before build_gauge. The LVGL init consumes the (4) global
    // file handles, which made play_wav's fileOpen fail (fk=-1) when the gauge was built first;
    // playing the intro before any LVGL work keeps the handles free.
#ifdef PLUGIN_MIC
    // No intro by default on the plugin build: the plugin owns ONE full-duplex I2S channel,
    // and its I2S_Play (TX) stops the shared clock when it ends, which wedges the always-on
    // mic RX → the gauge then reads silence (the native path below can play first because it
    // starts the mic AFTER the intro). Opt in with -DPLUGIN_INTRO if you accept that risk.
#ifdef PLUGIN_INTRO
    audioPlay(INTRO_WAV);
#endif
#else
    es8311_init();                       // DAC for the intro
    es8311_volume(60);                   // moderate
    play_wav(INTRO_WAV);                 // native: 128-frame chunks (P4 DMA-safe), finite TX timeout
#endif
    dbg_stage = 1;                        // intro done

    build_gauge();                       // then show the gauge
    dbg_stage = 2;                        // gauge built

#ifdef PLUGIN_MIC
    micok = 1;                            // the audio plugin already owns + inited the ES7210 mic;
                                          // a quiet plugin just yields n=0 → level read skips (no crash)
#else
    es7210_init();                       // mic for the live gauge
    micok = (i2sMicBegin(MIC_MCLK, MIC_BCLK, MIC_WS, MIC_DIN, MIC_RATE) == 0);
    if (!micok) { addLog("loudness_gauge: mic FAILED"); }
#endif
    dbg_stage = 3;                        // complete
    return 0;
}