ESP32-S3 + MAX98357A: Costruisci un simulatore di suono del motore V8 — tutorial completo (audio digitale I2S + encoder rotativo KY-040 per controllare l'acceleratore)
Usa l'ESP32-S3 per pilotare il modulo amplificatore MAX98357A, insieme all'encoder rotativo KY-040, e sintetizza in tempo reale e puramente via codice il suono di un motore V8: l'acceleratore è controllato manualmente dall'encoder e il suono esce in tempo reale dall'altoparlante. Include collegamenti completi, codice e note di troubleshooting.

TL;DR (per iniziare in fretta):
- Collegamenti: BCLK del MAX98357A → GPIO16, LRC → GPIO17, DIN → GPIO15; CLK del KY-040 → GPIO5, DT → GPIO6, SW → GPIO7
- Come scheda seleziona ESP32S3 Dev Module, come PSRAM seleziona QSPI PSRAM (sbagli e vai in OOM, non chiedermi come lo so)
- Ruotare l’encoder in senso orario = ridurre l’acceleratore, in senso antiorario = aumentare l’acceleratore, pressione = ritorno al minimo
- Flasha, alimenta, goditi il tuo “veicolo elettrico V8”
Difficoltà: ⭐⭐⭐☆☆ (richiede di saper fare i collegamenti di base su Arduino e il flashing) Tempo previsto: 45 minuti Ambiente di test: Arduino IDE 2.3.8 + ESP32 Arduino Core 3.3.10 + ESP32-S3-WROOM-1-N16R8 (16MB Flash + 8MB PSRAM)
Premessa
Chi ha mai guidato una bicicletta elettrica conosce quell’imbarazzo: ti avvicini silenziosamente ai pedoni da dietro, loro si spaventano a morte, si girano e ti lanciano un’occhiata del tipo “perché non fai rumore?” — e tu puoi solo rispondere con un sorriso imbarazzato, perché la tua bici davvero… non fa rumore.
I veicoli elettrici fanno risparmiare carburante e sono ecologici, ma c’è una cosa che fa impazzire: sono troppo silenziosi. Così silenziosi da sembrare un fantasma che scivola lungo la strada.
Così ho cominciato a chiedermi: se non possiamo contare sul suono naturale del motore, possiamo crearne uno da soli? Non il “bip-bip” di un clacson economico, ma… il rombo di un motore V8? Profondo, potente, che tuona quando schiacci l’acceleratore.
L’obiettivo di questo articolo è: usare ESP32-S3 + modulo amplificatore MAX98357A + encoder rotativo KY-040 per sintetizzare puramente via codice il rombo di un motore V8, con l’acceleratore controllato manualmente dall’encoder e il suono riprodotto in tempo reale dall’altoparlante. Niente campionamenti, niente file audio da riprodurre: tutto è generato in tempo reale tramite calcoli matematici.
Effetto dell’esperimento
Ruotando l’encoder KY-040 si aumenta l’acceleratore: l’altoparlante passa gradualmente dal rombo profondo del minimo al frastuono del motore ad alti regimi; premendo il pulsante dell’encoder, l’acceleratore torna immediatamente a zero, ripristinando il regime di minimo. L’intera transizione del suono è fluida, senza salti bruschi, e il risultato suona piuttosto convincente.
---
Descrizione dei componenti
La scheda di sviluppo (ESP32-S3) non viene descritta, ci concentriamo sugli altri due protagonisti.
MAX98357A — Il traduttore di segnali digitali
Immagina di avere una registrazione digitale (una sequenza di 0 e 1), ma l’altoparlante capisce solo segnali analogici (variazioni di tensione). Il MAX98357A è l’interprete simultaneo tra i due: riceve l’audio digitale inviato dall’ESP32-S3 tramite il protocollo I2S, lo converte in tempo reale in corrente analogica capace di pilotare l’altoparlante, e integra un amplificatore da 3W, senza bisogno di circuiti di amplificazione aggiuntivi.
| Parametro | Valore |
|---|---|
| Tensione di alimentazione | 2.5V ~ 5.5V |
| Potenza di uscita | 3.2W (carico 4Ω, alimentazione 5V) |
| Frequenze di campionamento supportate | 8kHz ~ 96kHz |
| Protocollo di comunicazione | I2S |
| Guadagno selezionabile | 3dB / 6dB / 9dB / 12dB / 15dB |
| Controllo del mute | Il pin SD portato basso silenzia l’uscita |
I motivi per sceglierlo sono semplici: connessione I2S diretta, senza filtro, package modularizzato, 3W sufficienti per l’uso in bici, e su Taobao lo trovi per meno di dieci yuan.
Descrizione dei pin
| Etichetta pin | Funzione |
|---|---|
| VIN | Polo positivo dell’alimentazione, collegato a 5V |
| GND | Massa dell’alimentazione |
| BCLK | Clock di bit I2S |
| LRC | Clock di parola I2S (selezione canale sinistro/destro) |
| DIN | Ingresso dati audio digitali I2S |
| SD | Controllo del mute, flottante o a livello alto = funzionamento normale, basso = mute |
| GAIN | Selezione del guadagno, flottante = 9dB di default |
Nota: il pin SD, sia lasciato non collegato sia collegato a 3.3V, riproduce comunque l’audio; se i collegamenti sono corretti ma non senti suono, controlla prima che il pin SD non sia stato inavvertitamente portato basso.
KY-040 — Il “pomello del volume” a rotazione infinita
Un normale potenziometro si blocca quando raggiunge il limite, invece il KY-040 è un encoder a rotazione infinita a 360°: non fornisce la posizione assoluta, ma ti dice “in che direzione e di quanti scatti hai girato”. In questo progetto lo uso per controllare l’acceleratore: senso orario = ridurre l’acceleratore, senso antiorario = aumentare l’acceleratore, pressione del pulsante = ritorno al minimo, con una sensazione tattile simile a quella di girare un vero pomello dell’acceleratore.
| Parametro | Valore |
|---|---|
| Tensione di funzionamento | 3.3V ~ 5V |
| Passi per giro | 20 passi |
| Segnali di uscita | Fase A (CLK) / Fase B (DT) / Pulsante (SW) |
| Tipo di interfaccia | GPIO digitale (con pull-up interno) |
Motivo della scelta: economico, comune, con pulsante incluso, a interruzione non impegna la CPU, e con l’architettura di task FreeRTOS non dà alcun problema.
Descrizione dei pin
| Etichetta pin | Funzione |
|---|---|
| CLK (Fase A) | Uscita fase A dell’encoder rotativo, collegata al pin di interrupt |
| DT (Fase B) | Uscita fase B dell’encoder rotativo, per determinare la direzione di rotazione |
| SW | Uscita pulsante, livello basso quando premuto |
| + | Polo positivo dell’alimentazione, collegato a 3.3V |
| GND | Massa dell’alimentazione |
Lista componenti (BOM)
| Componente | Modello/specifica | Quantità | Note |
|---|---|---|---|
| Scheda di sviluppo | ESP32-S3-WROOM-1-N16R8 | 1 | 16MB Flash + 8MB PSRAM, la PSRAM è obbligatoria |
| Modulo amplificatore I2S | MAX98357A | 1 | Include basetta del modulo, la versione senza saldature è più comoda |
| Modulo encoder rotativo | KY-040 | 1 | Con pulsante |
| Altoparlante piccolo | 4Ω 3W | 1 | Oppure 8Ω, il volume sarà leggermente più basso |
| Cavetti jumper | Maschio-maschio / maschio-femmina | diversi | Per i collegamenti |
| Breadboard | qualsiasi | 1 | Facoltativa, fissa i collegamenti più comodamente |
Modalità di collegamento
MAX98357A ↔ ESP32-S3
| MAX98357A | ESP32-S3 |
|---|---|
| VIN | 5V |
| GND | GND |
| BCLK | GPIO16 |
| LRC | GPIO17 |
| DIN | GPIO15 |
KY-040 ↔ ESP32-S3
| KY-040 | ESP32-S3 |
|---|---|
| CLK | GPIO5 |
| DT | GPIO6 |
| SW | GPIO7 |
| + | 3.3V |
| GND | GND |
Ti consiglio di spuntare ogni filo sulla tabella man mano che lo colleghi: questa abitudine ti fa risparmiare l’80% del tempo di debugging. Soprattutto il GND: avere tutti i moduli con massa comune è il prerequisito per un audio corretto — quando tutti parlano la stessa lingua, il segnale passa in modo preciso.
Librerie da installare
Questo progetto non dipende da alcuna libreria audio di terze parti: l’audio è interamente sintetizzato in tempo reale dal codice, e si usa solo il driver/i2s.h incluso nell’ESP32 Arduino Core.
Ti basta verificare il seguente ambiente in Arduino IDE:
| Voce | Requisito |
|---|---|
| Arduino IDE | 2.3.8 (test superato) |
| ESP32 Arduino Core | 3.3.10 (cerca esp32 nel Board Manager e installa) |
| Opzione scheda | ESP32S3 Dev Module |
| Opzione PSRAM | QSPI PSRAM (se sbagli questa vai direttamente in OOM, vedi le note di troubleshooting) |
| Flash Size | 16MB |
| Upload Speed | 921600 |
Nel menu Strumenti (Tools) di Arduino IDE controlla ogni voce, in particolare la riga della PSRAM.
Codice completo + spiegazione
/*
* ESP32-S3 + MAX98357A + encoder rotativo KY-040
* Simulatore del suono di un motore V8
*
* Collegamenti:
* MAX98357A ESP32-S3
* VIN -> 5V
* GND -> GND
* BCLK -> GPIO16
* LRC -> GPIO17
* DIN -> GPIO15
*
* KY-040 ESP32-S3
* CLK -> GPIO5
* DT -> GPIO6
* SW -> GPIO7 (pressione azzera l'acceleratore)
* + -> 3.3V
* GND -> GND
*
* Istruzioni d'uso:
* Rotazione in senso orario = riduce l'acceleratore
* Rotazione in senso antiorario = aumenta l'acceleratore
* Pressione dell'encoder = azzera l'acceleratore (ritorno al minimo)
*
* Baud rate seriale: 115200
*/
#include <Arduino.h>
#include <driver/i2s.h>
#include <math.h>
// -----------------------------------------------
// Se riscontri riavvi per Brownout, imposta qui a 1 per test temporanei
// Per l'uso finale mantieni 0: non è consigliabile disabilitare a lungo
// la protezione di sottotensione
// -----------------------------------------------
#define DISABLE_BROWNOUT_FOR_TEST 0
#if DISABLE_BROWNOUT_FOR_TEST
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#endif
#ifndef M_PI
#define M_PI 3.14159265358979323846f
#endif
// ================= Passo 1: definizione pin I2S =================
#define I2S_BCLK 16
#define I2S_LRC 17
#define I2S_DOUT 15
#define I2S_PORT I2S_NUM_0
// ================= Passo 2: definizione pin KY-040 =================
#define ENCODER_CLK_PIN 5
#define ENCODER_DT_PIN 6
#define ENCODER_SW_PIN 7
// ================= Parametri acceleratore da encoder =================
// Variazione di acceleratore per ogni scatto (range 0.0~1.0)
// Riduci questo valore = servono più scatti per arrivare all'acceleratore massimo, sensazione più fine
#define ENCODER_STEP_SIZE 0.1f
// Coefficiente di smoothing dell'acceleratore (più alto = risposta più veloce, più basso = transizione più fluida)
#define ENCODER_SMOOTHING 1.2f
// Tempo di debounce dell'encoder (microsecondi), evita che una rotazione venga letta più volte
#define ENCODER_DEBOUNCE_US 200
// Tempo di debounce del pulsante (millisecondi)
#define BUTTON_DEBOUNCE_MS 200
// ================= Parametri base audio =================
#define SAMPLE_RATE 22050 // Frequenza di campionamento, in Hz
#define DMA_BUF_COUNT 8 // Numero di buffer DMA
#define DMA_BUF_LEN 256 // Numero di campioni per ogni buffer DMA
// ================= Parametri regime motore =================
#define RPM_IDLE 800.0f // Regime di minimo (RPM)
#define RPM_MAX 8000.0f // Regime massimo (RPM)
#define RPM_SMOOTHING 0.006f // Coefficiente di smoothing del regime, più basso = più simile a un motore reale
#define NUM_CYLINDERS 8 // V8 = 8 cilindri
// ================= Ritmo dei colpi di scarico =================
// Al minimo 2 colpi al secondo, al massimo 7.6 colpi al secondo
#define THUMP_HZ_IDLE 2.0f
#define THUMP_HZ_MAX 7.6f
// ================= Parametri di volume =================
#define MASTER_VOLUME 1.00f
#define PCM_OUTPUT_SCALE 26000.0f // Coefficiente di scala finale verso PCM a 16 bit
// Volume del suono motore di fondo (minimo / massimo)
#define BACKGROUND_GAIN_IDLE 0.45f
#define BACKGROUND_GAIN_MAX 0.60f
// Volume del livello principale di colpi (minimo / massimo)
#define THUMP_LAYER_GAIN_IDLE 0.75f
#define THUMP_LAYER_GAIN_MAX 1.05f
// ================= Parametri del colpo tipo scarico dritto racing =================
// I seguenti parametri controllano la forma d'onda di ogni colpo di scarico, regolali con cautela
#define THUMP_ATTACK_MS 5.0f // Tempo di attacco (ms)
#define THUMP_BODY_MS 38.0f // Durata del corpo (ms)
#define THUMP_TAIL_MS 62.0f // Tempo di decadimento della coda (ms)
#define THUMP_F_START 105.0f // Frequenza iniziale del colpo (Hz)
#define THUMP_F_BODY 82.0f // Frequenza del corpo (Hz)
#define THUMP_F_END 64.0f // Frequenza della coda (Hz)
#define THUMP_NOISE_MIX 0.22f // Proporzione di rumore miscelato (simula il flusso di scarico)
#define THUMP_TONE2_MIX 0.30f // Proporzione di seconda armonica
#define THUMP_TONE3_MIX 0.16f // Proporzione di terza armonica
#define THUMP_SUB_MIX 0.08f // Proporzione sub-bassa (accentua la sensazione grave)
#define THUMP_DRIVE 2.10f // Saturazione della forma d'onda (intensità del soft-clip tanh)
#define THUMP_BURST_MIX 0.28f // Proporzione di rumore di flusso nella fase di burst
#define THUMP_REBOUND_DELAY_MS 30.0f // Ritardo del rimbalzo di scarico (ms), simula la risonanza del tubo
#define THUMP_REBOUND_GAIN 0.18f // Guadagno del rimbalzo
#define THUMP_ALT_GAIN 0.94f // Differenza di guadagno tra cilindri alternati, simula accensione non uniforme
#define THUMP_SWING 0.06f // Swing del ritmo, aumenta il groove
#define THUMP_TABLE_GAIN 2.50f // Guadagno complessivo della tabella della forma d'onda del colpo
// ================= Definizione delle tabelle di lookup =================
#define SINE_TABLE_SIZE 2048 // Dimensione della tabella del seno (più grande = più precisione, più memoria)
#define THUMP_TABLE_MAX 8000 // Numero massimo di campioni nella tabella del colpo
float sineTable[SINE_TABLE_SIZE];
float thumpTable[THUMP_TABLE_MAX];
int thumpTableLen = 0;
// Buffer di uscita stereo (DMA_BUF_LEN campioni per ciascun canale, L e R)
static int16_t stereoBuffer[DMA_BUF_LEN * 2];
// ================= Variabili di stato globali =================
volatile float throttleValue = 0.0f; // Valore di acceleratore attuale, filtrato (0.0~1.0)
volatile float targetThrottle = 0.0f; // Acceleratore obiettivo impostato dall'encoder
volatile float targetRPM = RPM_IDLE;
volatile float currentRPM = RPM_IDLE;
volatile float currentThumpHz = THUMP_HZ_IDLE;
uint32_t noiseSeed = 123456789;
// Tabella degli sfasamenti dei cilindri del V8 (simula accensione a intervalli di 90°)
float cylinderPhase[NUM_CYLINDERS];
const float firingAngles[NUM_CYLINDERS] = {
0.0f, 90.0f, 150.0f, 210.0f,
270.0f, 330.0f, 390.0f, 450.0f
};
// ================= Variabili relative all'interrupt dell'encoder =================
volatile int encoderPosition = 0;
volatile unsigned long lastEncoderInterruptUs = 0;
volatile bool encoderButtonPressed = false;
volatile unsigned long lastButtonPressMs = 0;
// ================= Funzioni di utilità =================
// Limita un valore a un range
static inline float clampf(float x, float lo, float hi) {
if (x < lo) return lo;
if (x > hi) return hi;
return x;
}
// Funzione a gradino smussato, rende la transizione più fluida (curva a S)
static inline float smoothstep01(float x) {
x = clampf(x, 0.0f, 1.0f);
return x * x * (3.0f - 2.0f * x);
}
// Calcola rapidamente il seno tramite tabella di lookup, molto più veloce di sinf(): indispensabile per l'audio in tempo reale
float fastSin(float phase) {
while (phase < 0.0f) phase += 1.0f;
while (phase >= 1.0f) phase -= 1.0f;
float idx = phase * (float)SINE_TABLE_SIZE;
int i0 = (int)idx;
int i1 = (i0 + 1) % SINE_TABLE_SIZE;
float frac = idx - (float)i0;
// Interpolazione lineare per maggiore precisione
return sineTable[i0] + frac * (sineTable[i1] - sineTable[i0]);
}
// Generatore di rumore pseudocasuale (metodo di congruenza lineare, veloce, usato per simulare il flusso d'aria)
float pseudoRandom() {
noiseSeed = noiseSeed * 1664525UL + 1013904223UL;
return ((float)(noiseSeed & 0x7FFFFFFF) / 1073741824.0f) - 1.0f;
}
// Pseudocasuale con seed indipendente (usato nella generazione della forma d'onda del colpo, per avere suono coerente ogni volta)
float localRandSigned(uint32_t &seed) {
seed = seed * 1664525UL + 1013904223UL;
return ((float)(seed & 0x7FFFFFFF) / 1073741824.0f) - 1.0f;
}
// ================= Interrupt dell'encoder: determina la direzione di rotazione =================
void IRAM_ATTR encoderISR() {
unsigned long nowUs = micros();
// Debounce: se due interrupt sono troppo ravvicinati li ignora, per evitare doppi trigger dovuti a rimbalzi meccanici
if (nowUs - lastEncoderInterruptUs < ENCODER_DEBOUNCE_US) return;
lastEncoderInterruptUs = nowUs;
// Si attiva sul fronte di discesa di CLK; in quel momento si legge il livello del pin DT per capire la direzione
// DT = LOW -> senso orario -> riduce l'acceleratore
// DT = HIGH -> senso antiorario -> aumenta l'acceleratore
int dtState = digitalRead(ENCODER_DT_PIN);
if (dtState == LOW) {
encoderPosition--; // Senso orario: riduce l'acceleratore
} else {
encoderPosition++; // Senso antiorario: aumenta l'acceleratore
}
}
// ================= Interrupt del pulsante: alla pressione azzera l'acceleratore =================
void IRAM_ATTR buttonISR() {
unsigned long nowMs = millis();
if (nowMs - lastButtonPressMs < BUTTON_DEBOUNCE_MS) return;
lastButtonPressMs = nowMs;
encoderButtonPressed = true;
}
// ================= Inizializza i pin e gli interrupt dell'encoder =================
void initEncoder() {
pinMode(ENCODER_CLK_PIN, INPUT_PULLUP);
pinMode(ENCODER_DT_PIN, INPUT_PULLUP);
pinMode(ENCODER_SW_PIN, INPUT_PULLUP);
// Il fronte di discesa di CLK attiva il rilevamento della rotazione
attachInterrupt(digitalPinToInterrupt(ENCODER_CLK_PIN), encoderISR, FALLING);
// Il fronte di discesa di SW attiva il rilevamento del pulsante (livello basso quando premuto)
attachInterrupt(digitalPinToInterrupt(ENCODER_SW_PIN), buttonISR, FALLING);
Serial.println("Inizializzazione encoder KY-040 completata");
}
// ================= Passo 3: precalcola la tabella di lookup del seno =================
// Calcola in anticipo 2048 valori di sin e li salva in memoria; in riproduzione si fa solo lookup, risparmiando CPU
void initSineTable() {
for (int i = 0; i < SINE_TABLE_SIZE; i++) {
sineTable[i] = sinf(2.0f * M_PI * (float)i / (float)SINE_TABLE_SIZE);
}
}
// ================= Inizializza gli sfasamenti degli 8 cilindri =================
void initCylinderPhases() {
for (int i = 0; i < NUM_CYLINDERS; i++) {
// Converte l'angolo in fase 0.0~1.0 (720° corrisponde a un ciclo di combustione completo)
cylinderPhase[i] = firingAngles[i] / 720.0f;
}
}
// ================= Genera la forma d'onda dell'impulso di scarico di un singolo cilindro =================
// phase è la fase attuale 0.0~1.0; restituisce l'ampiezza in quell'istante
float generateCylinderPulse(float phase) {
while (phase < 0.0f) phase += 1.0f;
while (phase >= 1.0f) phase -= 1.0f;
float pulse = 0.0f;
if (phase < 0.30f) {
// Primi 30%: rapida salita, simula l'urto di apertura della valvola di scarico
float t = phase / 0.30f;
pulse = sinf(M_PI * t) * expf(-2.2f * t) * 1.35f;
} else if (phase < 0.50f) {
// 30%~50%: lieve rimbalzo, simula la contropressione del tubo
float t = (phase - 0.30f) / 0.20f;
pulse = -0.25f * sinf(M_PI * 2.0f * t) * expf(-5.0f * t);
}
// Ultimi 50%: silenzio, in attesa dello scarico successivo
return pulse;
}
// ================= Passo 4: precalcola la tabella della forma d'onda del colpo =================
// Precalcola un intero "colpo" e lo salva in un array; in riproduzione basta leggerlo, risparmiando CPU
void buildStraightPipeThumpTable() {
int attackS = (int)(THUMP_ATTACK_MS * SAMPLE_RATE / 1000.0f);
int bodyS = (int)(THUMP_BODY_MS * SAMPLE_RATE / 1000.0f);
int tailS = (int)(THUMP_TAIL_MS * SAMPLE_RATE / 1000.0f);
int reboundS = (int)(THUMP_REBOUND_DELAY_MS * SAMPLE_RATE / 1000.0f);
if (attackS < 1) attackS = 1;
if (bodyS < 1) bodyS = 1;
if (tailS < 1) tailS = 1;
int mainLen = attackS + bodyS + tailS;
int totalLen = mainLen + reboundS + tailS / 2; // Aggiunge la coda del rimbalzo
if (totalLen > THUMP_TABLE_MAX) totalLen = THUMP_TABLE_MAX;
float phase1 = 0.0f; // Fase della frequenza fondamentale
float phase2 = 0.0f; // Fase della seconda armonica
float phase3 = 0.0f; // Fase della terza armonica
float phaseSub = 0.0f; // Fase sub-bassa
float noiseLP1 = 0.0f; // Stato del filtro passa-basso 1
float noiseLP2 = 0.0f; // Stato del filtro passa-basso 2
uint32_t seed = 24681357;
for (int i = 0; i < totalLen; i++) {
// --- Calcola l'inviluppo principale (attacco -> corpo -> decadimento) ---
float env1 = 0.0f;
if (i < attackS) {
float x = (float)i / (float)attackS;
env1 = smoothstep01(x);
env1 = env1 * env1; // Quadrato per rendere l'attacco più deciso
} else if (i < attackS + bodyS) {
float x = (float)(i - attackS) / (float)bodyS;
env1 = 1.0f - 0.28f * x;
env1 += 0.10f * sinf(2.0f * M_PI * x) * (1.0f - x);
} else if (i < mainLen) {
float x = (float)(i - attackS - bodyS) / (float)tailS;
env1 = 0.72f * expf(-3.6f * x);
env1 += 0.04f * sinf(5.0f * M_PI * x) * expf(-4.0f * x);
}
// --- Calcola l'inviluppo del rimbalzo (una piccola eco ritardata) ---
int j = i - reboundS;
float env2 = 0.0f;
if (j >= 0) {
if (j < attackS) {
float x = (float)j / (float)attackS;
env2 = smoothstep01(x);
env2 = env2 * env2;
} else if (j < attackS + bodyS) {
float x = (float)(j - attackS) / (float)bodyS;
env2 = 1.0f - 0.28f * x;
} else if (j < mainLen) {
float x = (float)(j - attackS - bodyS) / (float)tailS;
env2 = 0.72f * expf(-3.8f * x);
}
env2 *= THUMP_REBOUND_GAIN; // Il rimbalzo è molto più basso del corpo
}
float env = clampf(env1 + env2, 0.0f, 1.5f);
// --- La frequenza scende nel tempo (simula l'abbassamento del tono dopo il rilascio della pressione di scarico) ---
float freq = THUMP_F_END;
if (i < attackS) {
freq = THUMP_F_START;
} else if (i < attackS + bodyS) {
float x = (float)(i - attackS) / (float)bodyS;
freq = THUMP_F_START + (THUMP_F_BODY - THUMP_F_START) * x;
} else if (i < mainLen) {
float x = (float)(i - attackS - bodyS) / (float)tailS;
freq = THUMP_F_BODY + (THUMP_F_END - THUMP_F_BODY) * x;
}
float inc1 = freq / (float)SAMPLE_RATE;
phase1 += inc1; if (phase1 >= 1.0f) phase1 -= 1.0f;
phase2 += inc1 * 2.0f; if (phase2 >= 1.0f) phase2 -= 1.0f;
phase3 += inc1 * 3.0f; if (phase3 >= 1.0f) phase3 -= 1.0f;
phaseSub += inc1 * 0.5f; if (phaseSub >= 1.0f) phaseSub -= 1.0f;
// --- Sintesi della parte tonale: fondamentale + armoniche + sub-bassa ---
float base = fastSin(phase1);
base = tanhf(base * THUMP_DRIVE); // Soft-clip, simula la distorsione non lineare dello scarico
float tonal =
0.82f * base
+ THUMP_TONE2_MIX * fastSin(phase2)
+ THUMP_TONE3_MIX * fastSin(phase3)
+ THUMP_SUB_MIX * fastSin(phaseSub);
// --- Sintesi della parte di rumore: simula il sibilo del flusso d'aria in uscita ---
float white = localRandSigned(seed);
noiseLP1 += 0.18f * (white - noiseLP1); // Due stadi di passa-basso, spostano il rumore verso il basso
noiseLP2 += 0.04f * (noiseLP1 - noiseLP2);
float bandNoise = noiseLP1 - noiseLP2; // Effetto passa-banda
float earlyEnv = env1;
if (i > (attackS + bodyS / 2)) earlyEnv *= 0.35f; // Nella seconda metà il rumore di flusso si attenua
float air = bandNoise * (THUMP_NOISE_MIX * (0.25f * env + THUMP_BURST_MIX * 0.75f * earlyEnv));
// --- Miscela tono e flusso, poi un altro soft-clip asimmetrico ---
float sample = tonal * env + air;
sample += 0.08f * env * env1; // Leggera sovrapposizione non lineare, per dare più corpo al suono
if (sample > 0.0f) {
sample = tanhf(sample * 1.15f) * 1.05f; // Mezzo ciclo positivo spinto un po' più su
} else {
sample = tanhf(sample * 0.85f); // Mezzo ciclo negativo compresso un po'
}
sample *= THUMP_TABLE_GAIN;
thumpTable[i] = clampf(sample, -1.0f, 1.0f);
}
thumpTableLen = totalLen;
Serial.printf("Tabella colpi generata, lunghezza=%d campioni, circa %d ms\n",
thumpTableLen,
(int)((float)thumpTableLen * 1000.0f / SAMPLE_RATE));
}
// ================= Passo 5: inizializza il driver I2S =================
void initI2S() {
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, // Stereo (un canale L e uno R)
.communication_format= I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = DMA_BUF_COUNT,
.dma_buf_len = DMA_BUF_LEN,
.use_apll = false,
.tx_desc_auto_clear = true, // Azzera automaticamente dopo l'invio, per evitare rumore
.fixed_mclk = 0
};
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_BCLK,
.ws_io_num = I2S_LRC,
.data_out_num = I2S_DOUT,
.data_in_num = I2S_PIN_NO_CHANGE // Solo invio, non riceve
};
esp_err_t err;
err = i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
if (err != ESP_OK) {
Serial.printf("Installazione driver I2S fallita: %d\n", (int)err);
while (1) delay(100);
}
err = i2s_set_pin(I2S_PORT, &pin_config);
if (err != ESP_OK) {
Serial.printf("Impostazione pin I2S fallita: %d\n", (int)err);
while (1) delay(100);
}
i2s_zero_dma_buffer(I2S_PORT);
Serial.println("Inizializzazione I2S completata");
}
// ================= Aggiornamento acceleratore (chiamato ogni 20ms da throttleTask) =================
void updateThrottle() {
// Gestione pulsante: alla pressione azzera posizione encoder e acceleratore
if (encoderButtonPressed) {
encoderButtonPressed = false;
encoderPosition = 0;
targetThrottle = 0.0f;
Serial.println(">>> Pulsante premuto: acceleratore azzerato!");
}
// Limita il range della posizione dell'encoder, per evitare di sforare 0~massimo
int maxSteps = (int)(1.0f / ENCODER_STEP_SIZE); // Default: 10 scatti per arrivare al massimo
if (encoderPosition < 0) encoderPosition = 0;
if (encoderPosition > maxSteps) encoderPosition = maxSteps;
// Converte gli scatti in un valore di acceleratore 0.0~1.0
targetThrottle = clampf((float)encoderPosition * ENCODER_STEP_SIZE, 0.0f, 1.0f);
// Smoothing: ogni volta avanza di un piccolo passo, per evitare salti improvvisi che produrrebbero clic nel suono
throttleValue += (targetThrottle - throttleValue) * ENCODER_SMOOTHING;
throttleValue = clampf(throttleValue, 0.0f, 1.0f);
// Calcola il regime obiettivo in base all'acceleratore
targetRPM = RPM_IDLE + throttleValue * (RPM_MAX - RPM_IDLE);
}
// ================= Task di generazione audio (core 1, priorità massima) =================
void audioTask(void *param) {
float crankPhase = 0.0f; // Fase dell'albero motore, pilotata da tutti i cilindri
float bgLpf = 0.0f; // Stato del filtro passa-basso del suono di fondo
float bgHpfIn = 0.0f; // Ingresso del filtro passa-alto del suono di fondo
float bgHpfOut = 0.0f; // Uscita del filtro passa-alto del suono di fondo
int playPosA = -1; // Posizione di riproduzione attuale della voce di colpo A (-1 = non attiva)
int playPosB = -1; // Voce di colpo B (fade-out del colpo precedente)
float gainA = 1.0f;
float gainB = 0.55f;
int samplesToNextTrigger = 0; // Campioni mancanti al prossimo trigger del colpo
bool altToggle = false; // Flag di alternanza dei cilindri
float thumpLpf = 0.0f; // Stato del filtro passa-basso del colpo
float outHpfIn = 0.0f; // Ingresso del filtro passa-alto di uscita
float outHpfOut = 0.0f; // Uscita del filtro passa-alto di uscita
uint32_t jitterSeed = 987654321;
unsigned long audioStartMs = millis();
Serial.println("Task audio avviato");
while (true) {
// --- Inseguimento smussato del regime (simula l'inerzia di un motore reale) ---
currentRPM += (targetRPM - currentRPM) * RPM_SMOOTHING;
// Valore normalizzato del regime attuale nel range 0.0~1.0
float rpmNorm = clampf((currentRPM - RPM_IDLE) / (RPM_MAX - RPM_IDLE), 0.0f, 1.0f);
// Incremento di fase dell'albero motore per ogni campione (ciclo a 4 tempi / 2)
float cycleIncrement = ((currentRPM / 60.0f) / (float)SAMPLE_RATE) / 2.0f;
// Frequenza del colpo attuale
float thumpHz = THUMP_HZ_IDLE + rpmNorm * (THUMP_HZ_MAX - THUMP_HZ_IDLE);
currentThumpHz = thumpHz;
// Il volume varia con il regime
float bgGain = BACKGROUND_GAIN_IDLE + rpmNorm * (BACKGROUND_GAIN_MAX - BACKGROUND_GAIN_IDLE);
float thumpLayerGain = THUMP_LAYER_GAIN_IDLE + rpmNorm * (THUMP_LAYER_GAIN_MAX - THUMP_LAYER_GAIN_IDLE);
// La frequenza di taglio del passa-basso sale con il regime (ad alti giri il suono di fondo è più luminoso)
float bgLpfAlpha = 0.16f + 0.55f * rpmNorm;
// Fade-in di avvio (per evitare il pop all'accensione)
float fadeIn = clampf((float)(millis() - audioStartMs) / 1800.0f, 0.0f, 1.0f);
// --- Genera audio campione per campione ---
for (int i = 0; i < DMA_BUF_LEN; i++) {
// ====================================================
// Livello 1: suono motore di fondo — somma degli impulsi di scarico degli 8 cilindri
// ====================================================
float bg = 0.0f;
for (int cyl = 0; cyl < NUM_CYLINDERS; cyl++) {
float phase = crankPhase - cylinderPhase[cyl];
while (phase < 0.0f) phase += 1.0f;
while (phase >= 1.0f) phase -= 1.0f;
float pulse = generateCylinderPulse(phase);
float cylGain = (cyl % 2 == 0) ? 1.0f : 0.82f; // Leggera differenza tra cilindri pari e dispari, più realistico
bg += pulse * cylGain;
}
bg /= (float)NUM_CYLINDERS * 0.42f;
// Aggiunge il livello armonico (enfatizza le basse frequenze, riduce il ronzio delle armoniche superiori)
float basePhase = crankPhase * 4.0f;
float harmonics = 0.0f;
harmonics += fastSin(basePhase) * 1.00f;
harmonics += fastSin(basePhase * 0.5f) * 0.60f; // Mezza frequenza: accentua la sensazione grave
harmonics += fastSin(basePhase * 1.5f) * 0.28f;
harmonics += fastSin(basePhase * 2.0f) * (0.25f + 0.10f * rpmNorm);
harmonics += fastSin(basePhase * 3.0f) * (0.08f + 0.08f * rpmNorm);
harmonics += fastSin(basePhase * 4.0f) * (0.03f * rpmNorm); // La 4ª armonica è la causa del ronzio, tenuta molto bassa
harmonics /= 2.4f;
bg = bg * 0.55f + harmonics * 0.45f;
bg = tanhf(bg * (1.05f + rpmNorm * 0.8f)); // Soft-clip, simula la non linearità dello scarico
// Aggiunge rumore meccanico alle basse frequenze (rombo, non sibilo)
float rumble = pseudoRandom();
float rumble2 = pseudoRandom();
bg += (rumble * 0.6f + rumble2 * 0.4f) * (0.008f + 0.018f * rpmNorm);
// Filtro passa-basso (rende il suono più smorzato, come se arrivasse da dentro il tubo di scarico)
float bgLpfAlpha2 = 0.18f + 0.45f * rpmNorm;
bgLpf += bgLpfAlpha2 * (bg - bgLpf);
bg = bgLpf;
// Leggero passa-alto (rimuove l'offset DC)
float bgHp = 0.992f * (bgHpfOut + bg - bgHpfIn);
bgHpfIn = bg;
bgHpfOut = bgHp;
bg = bg * 0.92f + bgHp * 0.08f;
bg *= bgGain;
// ====================================================
// Livello 2: colpo principale — effetto scarico dritto racing
// ====================================================
// Quando il timer scade, attiva un nuovo colpo
if (samplesToNextTrigger <= 0) {
// Fa andare in fade-out il colpo precedente come voce B (per sovrapporre le code)
if (playPosA >= 0 && playPosA < thumpTableLen) {
playPosB = playPosA;
gainB = gainA * 0.50f;
}
playPosA = 0;
// Alternanza pari/dispari: simula la lieve differenza di forza tra le accensioni dei cilindri del V8
gainA = altToggle ? THUMP_ALT_GAIN : 1.0f;
// Calcola l'intervallo al prossimo trigger (aggiunge Swing e jitter per dare più groove al ritmo)
float intervalSamples = (float)SAMPLE_RATE / thumpHz;
float swingFactor = altToggle ? (1.0f - THUMP_SWING) : (1.0f + THUMP_SWING);
float jitter = 1.0f + localRandSigned(jitterSeed) * 0.025f;
samplesToNextTrigger = (int)clampf(intervalSamples * swingFactor * jitter, 1.0f, 999999.0f);
altToggle = !altToggle;
}
samplesToNextTrigger--;
float thump = 0.0f;
// Legge la voce A
if (playPosA >= 0) {
if (playPosA < thumpTableLen) {
thump += thumpTable[playPosA++] * gainA;
} else {
playPosA = -1;
}
}
// Legge la voce B (code in fade-out del colpo precedente)
if (playPosB >= 0) {
if (playPosB < thumpTableLen) {
thump += thumpTable[playPosB++] * gainB;
gainB *= 0.9992f; // Lento fade-out
} else {
playPosB = -1;
}
}
// Passa-basso che arrotonda i bordi del colpo, rendendolo meno duro
thumpLpf += 0.58f * (thump - thumpLpf);
thump = thumpLpf * thumpLayerGain;
// ====================================================
// Livello 3: miscela dei due livelli e uscita
// ====================================================
float sample = bg + thump;
// Passa-alto finale di uscita (rimuove la deriva DC alle basse frequenze)
float outHp = 0.988f * (outHpfOut + sample - outHpfIn);
outHpfIn = sample;
outHpfOut = outHp;
sample = sample * 0.86f + outHp * 0.14f;
// Soft-clip generale (evita clipping quando i due livelli si sommano)
sample = tanhf(sample * (1.05f + 0.22f * rpmNorm));
sample *= MASTER_VOLUME * fadeIn;
sample = clampf(sample, -0.98f, 0.98f);
// Converte in PCM a 16 bit, canali L e R uguali (altoparlante mono)
int16_t out = (int16_t)(sample * PCM_OUTPUT_SCALE);
stereoBuffer[i * 2] = out;
stereoBuffer[i * 2 + 1] = out;
// Avanza la fase dell'albero motore
crankPhase += cycleIncrement;
if (crankPhase >= 1.0f) crankPhase -= 1.0f;
}
// Scrive questo blocco di dati audio nel DMA I2S; poi genera il blocco successivo
size_t bytesWritten = 0;
i2s_write(I2S_PORT, stereoBuffer, sizeof(stereoBuffer), &bytesWritten, portMAX_DELAY);
}
}
// ================= Task acceleratore (core 0, priorità bassa) =================
void throttleTask(void *param) {
while (true) {
updateThrottle();
vTaskDelay(pdMS_TO_TICKS(20)); // Aggiorna l'acceleratore ogni 20ms, sufficientemente fluido
}
}
// ================= Task di monitoraggio seriale (core 0, priorità minima) =================
void monitorTask(void *param) {
char buf[128];
while (true) {
int rpmInt = (int)(currentRPM + 0.5f);
int targetInt = (int)(targetRPM + 0.5f);
int throttlePct = (int)(throttleValue * 100.0f + 0.5f);
int thumpHz10 = (int)(currentThumpHz * 10.0f + 0.5f);
snprintf(buf, sizeof(buf),
"RPM=%d obiettivo=%d acceleratore=%d%% encoder=%d freqColpo=%d.%dHz",
rpmInt, targetInt, throttlePct, encoderPosition,
thumpHz10 / 10, thumpHz10 % 10);
Serial.println(buf);
vTaskDelay(pdMS_TO_TICKS(700));
}
}
// ================= setup: inizializzazione del sistema =================
void setup() {
#if DISABLE_BROWNOUT_FOR_TEST
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
#endif
Serial.begin(115200);
delay(1000);
// All'avvio controlla lo stato della memoria (se PSRAM è 0, significa che non è stata attivata: torna a impostare QSPI)
Serial.printf("SRAM su chip libera: %d byte\n", ESP.getFreeHeap());
Serial.printf("PSRAM esterna libera: %d byte\n", ESP.getFreePsram());
Serial.println("====================================");
Serial.println("Simulatore di suono V8 ESP32-S3");
Serial.println("Colpo principale: scarico dritto racing");
Serial.println("Controllo acceleratore: encoder rotativo KY-040");
Serial.println("====================================");
initEncoder();
initSineTable();
initCylinderPhases();
buildStraightPipeThumpTable();
initI2S();
// Task audio: core 1, priorità massima, stack 12KB
xTaskCreatePinnedToCore(audioTask, "AudioTask", 12288, NULL, configMAX_PRIORITIES - 1, NULL, 1);
// Task acceleratore: core 0, priorità 2, stack 3KB
xTaskCreatePinnedToCore(throttleTask, "Throttle", 3072, NULL, 2, NULL, 0);
// Task monitoraggio: core 0, priorità minima, stack 4KB (non troppo piccolo, altrimenti overflow dello stack)
xTaskCreatePinnedToCore(monitorTask, "Monitor", 4096, NULL, 1, NULL, 0);
Serial.println("Avvio del sistema completato. Ruota l'encoder per controllare l'acceleratore, premi per azzerarlo");
}
// loop praticamente inattivo: tutto il lavoro è delegato ai task FreeRTOS
void loop() {
vTaskDelay(pdMS_TO_TICKS(1000));
}
Spiegazione del codice
L’intero programma è composto da tre task paralleli, gestiti dallo scheduler FreeRTOS, che non si intralciano a vicenda:
| Task | Su quale core | Priorità | Cosa fa |
|---|---|---|---|
audioTask |
Core 1 | Massima | Sintetizza l’audio campione per campione, lo scrive nel DMA I2S |
throttleTask |
Core 0 | Media | Legge l’encoder ogni 20ms e aggiorna l’acceleratore |
monitorTask |
Core 0 | Minima | Stampa lo stato sulla seriale ogni 700ms |
La logica centrale della sintesi sonora si divide in tre livelli:
Livello 1: il suono motore di fondo. Ciascuno degli 8 cilindri mantiene una propria fase; ogni cilindro, seguendo gli angoli di accensione del V8 (0°, 90°, 150°…450°), attiva in sequenza la forma d’onda dell’impulso di scarico. La somma degli output degli 8 cilindri produce quel rombo grave e continuo. Sopra gli impulsi dei cilindri si aggiungono la fondamentale e alcune armoniche, per dare più stratificazione al suono del motore.
Livello 2: il colpo principale. A intervalli regolari (la frequenza è decisa da thumpHz), si legge dalla tabella precalcolata della forma d’onda un “colpo” completo e lo si riproduce. Il colpo stesso è composto da tre fasi di inviluppo — attacco, corpo, decadimento — con una discesa di frequenza (simula il rilascio della pressione di scarico) e un ritardo di rimbalzo (simula la risonanza del tubo): il risultato ricorda il suono di uno scarico dritto racing.
Livello 3: miscela e uscita. Sommati i due livelli, si applica un soft-clip generale per evitare il clipping, poi si moltiplica per il coefficiente di fade-in (per evitare il pop all’accensione) e infine si scrive il dato come PCM stereo a 16 bit verso l’I2S.
Strumento di debug dei campioni di colpo (facoltativo)
Per trovare più in fretta il suono di scarico più adatto, ho preparato una versione separata di codice di test a rotazione seriale: integra 30 set di parametri predefiniti, commutabili con comandi seriali, per confrontare direttamente quale “colpo” ti soddisfa di più. Nel programma principale, alla fine, viene usato il preset numero 23, “Scarico dritto racing”.
/*
* ESP32-S3 + MAX98357A
* Tester a rotazione dei campioni di colpo V2
* 30 campioni + volume notevolmente aumentato
*
* Collegamenti:
* BCLK -> GPIO16
* LRC -> GPIO17
* DIN -> GPIO15
*
* Comandi seriali (115200):
* n successivo
* p precedente
* r ripeti
* s ferma la rotazione automatica
* a avvia la rotazione automatica
* b attiva/disattiva lo strato di fondo
* 1~30 salta al numero corrispondente
* h aiuto
*/
#include <Arduino.h>
#include <driver/i2s.h>
#include <math.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846f
#endif
#define I2S_BCLK 16
#define I2S_LRC 17
#define I2S_DOUT 15
#define I2S_PORT I2S_NUM_0
#define SAMPLE_RATE 22050
#define DMA_BUF_COUNT 8
#define DMA_BUF_LEN 256
#define PRESET_PLAY_MS 5000
#define SLOW_PART_MS 2500
#define TEST_SLOW_HZ 2.2f
#define TEST_FAST_HZ 5.0f
#define SINE_TABLE_SIZE 2048
#define THUMP_TABLE_MAX 8000
float sineTable[SINE_TABLE_SIZE];
float thumpTable[THUMP_TABLE_MAX];
int thumpTableLen = 0;
static int16_t stereoBuffer[DMA_BUF_LEN * 2];
volatile int requestedPresetIndex = 0;
volatile uint32_t presetStartMs = 0;
volatile bool backgroundEnabled = true;
bool autoPlay = true;
uint32_t lastSwitchMs = 0;
String cmdBuffer;
static inline float clampf(float x, float lo, float hi) {
if (x < lo) return lo;
if (x > hi) return hi;
return x;
}
static inline float smoothstep01(float x) {
x = clampf(x, 0.0f, 1.0f);
return x * x * (3.0f - 2.0f * x);
}
float fastSin(float phase) {
while (phase < 0.0f) phase += 1.0f;
while (phase >= 1.0f) phase -= 1.0f;
float idx = phase * (float)SINE_TABLE_SIZE;
int i0 = (int)idx;
int i1 = (i0 + 1) % SINE_TABLE_SIZE;
float frac = idx - (float)i0;
return sineTable[i0] + frac * (sineTable[i1] - sineTable[i0]);
}
float localRandSigned(uint32_t &seed) {
seed = seed * 1664525UL + 1013904223UL;
return ((float)(seed & 0x7FFFFFFF) / 1073741824.0f) - 1.0f;
}
// ================= Struttura dei parametri dei campioni =================
struct ThumpPreset {
const char* name;
float attackMs;
float bodyMs;
float tailMs;
float fStart;
float fBody;
float fEnd;
float noiseMix;
float tone2Mix;
float tone3Mix;
float subMix;
float drive;
float burstMix;
float reboundDelayMs;
float reboundGain;
float altGain;
float swing;
float gain;
float rumbleGain;
};
// nome atk body tail fS fB fE noise t2 t3 sub drv burst rebMs rebG alt swng gain rumble
const ThumpPreset presets[] = {
{"01 Profondo grande cilindrata", 12, 65, 100, 55, 42, 34, 0.18, 0.24, 0.08, 0.28, 1.7, 0.18, 44, 0.22, 1.00, 0.00, 2.8, 0.20},
{"02 Più rotondo e denso", 14, 75, 130, 52, 40, 32, 0.12, 0.18, 0.04, 0.32, 1.5, 0.10, 50, 0.18, 1.00, 0.00, 2.9, 0.16},
{"03 Tromba corta potenziata A", 7, 42, 65, 100, 80, 65, 0.16, 0.30, 0.14, 0.06, 1.6, 0.16, 32, 0.14, 1.00, 0.00, 2.6, 0.12},
{"04 Tromba corta potenziata B", 5, 35, 55, 120, 95, 78, 0.14, 0.36, 0.20, 0.04, 1.7, 0.12, 26, 0.12, 1.00, 0.00, 2.5, 0.10},
{"05 V8 americano al minimo", 9, 55, 95, 72, 56, 44, 0.22, 0.26, 0.10, 0.14, 1.8, 0.24, 42, 0.30, 0.80, 0.20, 2.7, 0.22},
{"06 Più gorgogliante irregolare", 11, 58, 105, 68, 52, 42, 0.24, 0.22, 0.08, 0.18, 1.8, 0.22, 54, 0.38, 0.72, 0.26, 2.8, 0.24},
{"07 Doppio colpo con controspinta evidente", 8, 48, 85, 80, 62, 48, 0.20, 0.26, 0.12, 0.12, 1.7, 0.20, 58, 0.48, 0.88, 0.14, 2.6, 0.18},
{"08 Ruvido ed esplosivo", 6, 40, 68, 90, 72, 56, 0.28, 0.32, 0.16, 0.08, 2.2, 0.32, 34, 0.22, 0.90, 0.10, 2.5, 0.15},
{"09 Estremamente spesso e sordo", 16, 85, 150, 48, 38, 30, 0.08, 0.14, 0.02, 0.36, 1.6, 0.06, 58, 0.20, 1.00, 0.00, 3.0, 0.14},
{"10 Colpo breve e potente", 4, 28, 45, 100, 78, 60, 0.14, 0.38, 0.20, 0.04, 1.8, 0.12, 22, 0.10, 1.00, 0.00, 2.4, 0.10},
{"11 Scarico rauco", 8, 50, 88, 82, 64, 50, 0.32, 0.24, 0.10, 0.10, 1.9, 0.34, 40, 0.26, 0.86, 0.12, 2.6, 0.16},
{"12 Cannone grave", 13, 68, 115, 58, 46, 36, 0.14, 0.20, 0.06, 0.30, 1.8, 0.14, 48, 0.26, 1.00, 0.00, 2.9, 0.20},
{"13 Colpo medio secco", 6, 36, 58, 130, 100, 78, 0.10, 0.40, 0.24, 0.02, 1.6, 0.08, 28, 0.10, 1.00, 0.00, 2.4, 0.08},
{"14 Doppio impulso gorgogliante", 7, 44, 78, 85, 66, 52, 0.18, 0.28, 0.14, 0.10, 1.8, 0.20, 20, 0.45, 0.82, 0.18, 2.6, 0.16},
{"15 Vecchio V8 lasco", 10, 60, 108, 72, 55, 44, 0.24, 0.22, 0.08, 0.16, 1.7, 0.20, 52, 0.32, 0.68, 0.30, 2.7, 0.22},
{"16 Test ultra spesso", 15, 95, 160, 54, 42, 32, 0.06, 0.14, 0.02, 0.38, 1.6, 0.04, 64, 0.18, 1.00, 0.00, 3.2, 0.12},
{"17 Stile Harley-Davidson", 8, 52, 90, 78, 58, 46, 0.26, 0.24, 0.10, 0.16, 1.9, 0.26, 48, 0.35, 0.65, 0.32, 2.8, 0.25},
{"18 Sportivo acuto ad alti giri", 4, 30, 50, 140, 110, 88, 0.12, 0.42, 0.28, 0.02, 1.8, 0.10, 20, 0.08, 1.00, 0.00, 2.3, 0.08},
{"19 Diesel ciac-ciac", 14, 48, 80, 65, 50, 42, 0.30, 0.18, 0.06, 0.20, 2.0, 0.28, 38, 0.40, 0.75, 0.22, 2.7, 0.20},
{"20 Cruiser grande cilindrata", 12, 72, 125, 60, 45, 36, 0.16, 0.20, 0.06, 0.34, 1.7, 0.12, 55, 0.24, 1.00, 0.00, 3.0, 0.18},
{"21 Ultra brutale esplosivo", 3, 25, 40, 110, 85, 68, 0.35, 0.34, 0.18, 0.06, 2.5, 0.40, 18, 0.15, 0.92, 0.08, 2.4, 0.12},
{"22 Grande cilindrata delicato", 16, 90, 140, 50, 40, 34, 0.10, 0.16, 0.04, 0.30, 1.4, 0.06, 60, 0.16, 1.00, 0.00, 3.0, 0.10},
{"23 Scarico dritto racing", 5, 38, 62, 105, 82, 64, 0.22, 0.30, 0.16, 0.08, 2.1, 0.28, 30, 0.18, 0.94, 0.06, 2.5, 0.14},
{"24 Profondo + forte controspinta", 10, 58, 95, 65, 50, 40, 0.18, 0.22, 0.08, 0.22, 1.8, 0.16, 65, 0.52, 0.85, 0.16, 2.8, 0.20},
{"25 Esplosione di flusso d'aria", 6, 35, 55, 88, 68, 52, 0.38, 0.20, 0.08, 0.10, 1.7, 0.45, 28, 0.14, 1.00, 0.00, 2.5, 0.12},
{"26 Sensazione 3 cilindri ciac-ciac", 10, 45, 75, 74, 58, 46, 0.20, 0.22, 0.10, 0.14, 1.8, 0.20, 36, 0.30, 0.60, 0.35, 2.6, 0.18},
{"27 Test subwoofer ultra grave", 18, 100, 180, 42, 32, 26, 0.06, 0.12, 0.02, 0.42, 1.5, 0.04, 70, 0.20, 1.00, 0.00, 3.4, 0.08},
{"28 Colpo a segno", 5, 32, 48, 95, 75, 58, 0.16, 0.34, 0.18, 0.06, 2.0, 0.16, 24, 0.12, 1.00, 0.00, 2.6, 0.10},
{"29 Rombo a tutto spettro", 8, 55, 90, 85, 65, 50, 0.20, 0.28, 0.14, 0.18, 1.9, 0.22, 42, 0.28, 0.88, 0.12, 2.8, 0.20},
{"30 Test contrasto estremo", 3, 20, 35, 150, 120, 90, 0.40, 0.44, 0.28, 0.02, 2.4, 0.45, 16, 0.08, 1.00, 0.00, 2.2, 0.06},
};
const int NUM_PRESETS = sizeof(presets) / sizeof(presets[0]);
// ================= Inizializzazione =================
void initSineTable() {
for (int i = 0; i < SINE_TABLE_SIZE; i++) {
sineTable[i] = sinf(2.0f * M_PI * (float)i / (float)SINE_TABLE_SIZE);
}
}
void initI2S() {
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = DMA_BUF_COUNT,
.dma_buf_len = DMA_BUF_LEN,
.use_apll = false,
.tx_desc_auto_clear = true,
.fixed_mclk = 0
};
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_BCLK,
.ws_io_num = I2S_LRC,
.data_out_num = I2S_DOUT,
.data_in_num = I2S_PIN_NO_CHANGE
};
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
i2s_zero_dma_buffer(I2S_PORT);
Serial.println("I2S OK");
}
// ================= Costruzione della tabella della forma d'onda =================
void buildThumpTable(int presetIndex) {
const ThumpPreset &p = presets[presetIndex];
int attackS = (int)(p.attackMs * SAMPLE_RATE / 1000.0f);
int bodyS = (int)(p.bodyMs * SAMPLE_RATE / 1000.0f);
int tailS = (int)(p.tailMs * SAMPLE_RATE / 1000.0f);
int reboundS = (int)(p.reboundDelayMs * SAMPLE_RATE / 1000.0f);
if (attackS < 1) attackS = 1;
if (bodyS < 1) bodyS = 1;
if (tailS < 1) tailS = 1;
int mainLen = attackS + bodyS + tailS;
int totalLen = mainLen + reboundS + tailS / 2;
if (totalLen > THUMP_TABLE_MAX) totalLen = THUMP_TABLE_MAX;
float phase1 = 0, phase2 = 0, phase3 = 0, phaseSub = 0;
float noiseLP1 = 0, noiseLP2 = 0;
uint32_t seed = 24681357;
for (int i = 0; i < totalLen; i++) {
float env1 = 0.0f;
if (i < attackS) {
float x = (float)i / (float)attackS;
env1 = smoothstep01(x);
env1 = env1 * env1;
} else if (i < attackS + bodyS) {
float x = (float)(i - attackS) / (float)bodyS;
env1 = 1.0f - 0.28f * x;
env1 += 0.10f * sinf(2.0f * M_PI * x) * (1.0f - x);
} else if (i < mainLen) {
float x = (float)(i - attackS - bodyS) / (float)tailS;
env1 = 0.72f * expf(-3.6f * x);
env1 += 0.04f * sinf(5.0f * M_PI * x) * expf(-4.0f * x);
}
int j = i - reboundS;
float env2 = 0.0f;
if (j >= 0) {
if (j < attackS) {
float x = (float)j / (float)attackS;
env2 = smoothstep01(x); env2 *= env2;
} else if (j < attackS + bodyS) {
float x = (float)(j - attackS) / (float)bodyS;
env2 = 1.0f - 0.28f * x;
} else if (j < mainLen) {
float x = (float)(j - attackS - bodyS) / (float)tailS;
env2 = 0.72f * expf(-3.8f * x);
}
env2 *= p.reboundGain;
}
float env = env1 + env2;
env = clampf(env, 0.0f, 1.5f);
float freq = p.fEnd;
if (i < attackS) freq = p.fStart;
else if (i < attackS + bodyS) {
float x = (float)(i - attackS) / (float)bodyS;
freq = p.fStart + (p.fBody - p.fStart) * x;
} else if (i < mainLen) {
float x = (float)(i - attackS - bodyS) / (float)tailS;
freq = p.fBody + (p.fEnd - p.fBody) * x;
}
float inc1 = freq / (float)SAMPLE_RATE;
phase1 += inc1; if (phase1 >= 1.0f) phase1 -= 1.0f;
phase2 += inc1 * 2; if (phase2 >= 1.0f) phase2 -= 1.0f;
phase3 += inc1 * 3; if (phase3 >= 1.0f) phase3 -= 1.0f;
phaseSub += inc1 * 0.5f; if (phaseSub >= 1.0f) phaseSub -= 1.0f;
float base = fastSin(phase1);
base = tanhf(base * p.drive);
float tonal = 0.82f * base
+ p.tone2Mix * fastSin(phase2)
+ p.tone3Mix * fastSin(phase3)
+ p.subMix * fastSin(phaseSub);
float white = localRandSigned(seed);
noiseLP1 += 0.18f * (white - noiseLP1);
noiseLP2 += 0.04f * (noiseLP1 - noiseLP2);
float bandNoise = noiseLP1 - noiseLP2;
float earlyEnv = env1;
if (i > (attackS + bodyS / 2)) earlyEnv *= 0.35f;
float air = bandNoise * (p.noiseMix * (0.25f * env + p.burstMix * 0.75f * earlyEnv));
float sample = tonal * env + air;
sample += 0.08f * env * env1;
if (sample > 0.0f) sample = tanhf(sample * 1.15f) * 1.05f;
else sample = tanhf(sample * 0.85f);
sample *= p.gain;
sample = clampf(sample, -1.0f, 1.0f);
thumpTable[i] = sample;
}
thumpTableLen = totalLen;
}
// ================= Controllo seriale =================
void showHelp() {
Serial.println();
Serial.println("===== Comandi =====");
Serial.println("n successivo");
Serial.println("p precedente");
Serial.println("r ripeti");
Serial.println("s ferma la rotazione automatica");
Serial.println("a avvia la rotazione automatica");
Serial.println("b attiva/disattiva lo sfondo");
Serial.println("1~30 salta al numero");
Serial.println("h aiuto");
Serial.println("================");
}
void printPresetInfo(int idx) {
Serial.println();
Serial.println("========================================");
Serial.print("Campione #");
Serial.print(idx + 1);
Serial.print(" / ");
Serial.println(NUM_PRESETS);
Serial.println(presets[idx].name);
Serial.print("Primi 2.5s colpi lenti, poi 2.5s colpi veloci - Sfondo: ");
Serial.println(backgroundEnabled ? "ON" : "OFF");
Serial.println("========================================");
}
void requestPreset(int idx) {
while (idx < 0) idx += NUM_PRESETS;
while (idx >= NUM_PRESETS) idx -= NUM_PRESETS;
requestedPresetIndex = idx;
presetStartMs = millis();
lastSwitchMs = millis();
printPresetInfo(idx);
}
void processCommand(String cmd) {
cmd.trim();
cmd.toLowerCase();
if (cmd.length() == 0) return;
if (cmd == "n") { requestPreset(requestedPresetIndex + 1); return; }
if (cmd == "p") { requestPreset(requestedPresetIndex - 1); return; }
if (cmd == "r") { requestPreset(requestedPresetIndex); return; }
if (cmd == "s") { autoPlay = false; Serial.println("Rotazione automatica fermata"); return; }
if (cmd == "a") { autoPlay = true; lastSwitchMs = millis(); Serial.println("Rotazione automatica avviata"); return; }
if (cmd == "b") { backgroundEnabled = !backgroundEnabled; Serial.print("Sfondo: "); Serial.println(backgroundEnabled ? "ON" : "OFF"); return; }
if (cmd == "h") { showHelp(); return; }
int n = cmd.toInt();
if (n >= 1 && n <= NUM_PRESETS) { requestPreset(n - 1); return; }
Serial.print("Sconosciuto: ");
Serial.println(cmd);
}
// ================= Task audio =================
void audioTask(void *param) {
int loadedPreset = -1;
ThumpPreset currentPreset;
int playPosA = -1, playPosB = -1;
float gainA = 1.0f, gainB = 0.5f;
int samplesToNextTrigger = 0;
bool altToggle = false;
float thumpLP = 0.0f;
float hpIn = 0.0f, hpOut = 0.0f;
float bgPhase1 = 0, bgPhase2 = 0;
float bgNoise1 = 0, bgNoise2 = 0;
uint32_t bgSeed = 123456789;
while (true) {
int req = requestedPresetIndex;
if (req != loadedPreset) {
currentPreset = presets[req];
buildThumpTable(req);
loadedPreset = req;
playPosA = -1; playPosB = -1;
gainA = 1.0f; gainB = 0.5f;
samplesToNextTrigger = 0;
altToggle = false;
thumpLP = 0.0f;
}
uint32_t ageMs = millis() - presetStartMs;
float baseHz = (ageMs < SLOW_PART_MS) ? TEST_SLOW_HZ : TEST_FAST_HZ;
float speedNorm = (ageMs < SLOW_PART_MS) ? 0.25f : 0.70f;
for (int i = 0; i < DMA_BUF_LEN; i++) {
if (samplesToNextTrigger <= 0) {
if (playPosA >= 0 && playPosA < thumpTableLen) {
playPosB = playPosA;
gainB = gainA * 0.55f;
}
playPosA = 0;
gainA = altToggle ? currentPreset.altGain : 1.0f;
float intervalSamples = (float)SAMPLE_RATE / baseHz;
float swingFactor = altToggle ? (1.0f - currentPreset.swing) : (1.0f + currentPreset.swing);
if (swingFactor < 0.2f) swingFactor = 0.2f;
samplesToNextTrigger = (int)(intervalSamples * swingFactor);
if (samplesToNextTrigger < 1) samplesToNextTrigger = 1;
altToggle = !altToggle;
}
samplesToNextTrigger--;
float thump = 0.0f;
if (playPosA >= 0) {
if (playPosA < thumpTableLen) { thump += thumpTable[playPosA] * gainA; playPosA++; }
else playPosA = -1;
}
if (playPosB >= 0) {
if (playPosB < thumpTableLen) { thump += thumpTable[playPosB] * gainB; playPosB++; gainB *= 0.9993f; }
else playPosB = -1;
}
thumpLP += 0.55f * (thump - thumpLP);
thump = thumpLP;
float bg = 0.0f;
if (backgroundEnabled) {
float bgFreq = 28.0f + speedNorm * 36.0f;
bgPhase1 += bgFreq / (float)SAMPLE_RATE;
if (bgPhase1 >= 1.0f) bgPhase1 -= 1.0f;
bgPhase2 += (bgFreq * 2.1f) / (float)SAMPLE_RATE;
if (bgPhase2 >= 1.0f) bgPhase2 -= 1.0f;
float white = localRandSigned(bgSeed);
bgNoise1 += 0.06f * (white - bgNoise1);
bgNoise2 += 0.015f * (bgNoise1 - bgNoise2);
bg = fastSin(bgPhase1) * 0.65f + fastSin(bgPhase2) * 0.18f + bgNoise2 * 0.07f;
bg = tanhf(bg * 1.35f) * currentPreset.rumbleGain;
}
float sample = thump + bg;
float hp = 0.985f * (hpOut + sample - hpIn);
hpIn = sample;
hpOut = hp;
sample = sample * 0.82f + hp * 0.18f;
// ★ Punto chiave: il guadagno di uscita finale è notevolmente aumentato
sample *= 1.8f;
sample = tanhf(sample * 1.1f);
sample = clampf(sample, -0.98f, 0.98f);
// ★ Uscita a piena scala
int16_t out = (int16_t)(sample * 30000.0f);
stereoBuffer[i * 2] = out;
stereoBuffer[i * 2 + 1] = out;
}
size_t bytesWritten = 0;
i2s_write(I2S_PORT, stereoBuffer, sizeof(stereoBuffer), &bytesWritten, portMAX_DELAY);
}
}
// ================= setup / loop =================
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println();
Serial.println("====================================");
Serial.println("Tester a rotazione dei campioni di colpo V2");
Serial.println("30 campioni + versione ad alto volume");
Serial.println("====================================");
initSineTable();
initI2S();
showHelp();
requestPreset(0);
xTaskCreatePinnedToCore(audioTask, "Audio", 10240, NULL, configMAX_PRIORITIES - 1, NULL, 1);
Serial.println("Inizio riproduzione...");
}
void loop() {
while (Serial.available()) {
char c = Serial.read();
if (c == '\r' || c == '\n') {
if (cmdBuffer.length() > 0) {
processCommand(cmdBuffer);
cmdBuffer = "";
}
} else {
cmdBuffer += c;
}
}
if (autoPlay) {
if (millis() - lastSwitchMs >= PRESET_PLAY_MS) {
int nextIdx = requestedPresetIndex + 1;
if (nextIdx >= NUM_PRESETS) nextIdx = 0;
requestPreset(nextIdx);
}
}
delay(10);
}
Risoluzione dei problemi comuni
Non temere, il 90% dei problemi nasce da questi punti; con una verifica mirata si risolvono quasi tutti:
Altoparlante completamente muto dopo l’alimentazione
Per prima cosa controlla il pin SD. Se il pin SD del MAX98357A viene inavvertitamente portato basso (ad esempio tocca il GND o non è lasciato flottante), il modulo entra in modalità mute. Lascia il pin SD flottante o collegalo a 3.3V, poi riavvia e riprova. Quindi, con il monitor seriale, verifica che l’inizializzazione I2S non abbia restituito errori e che nel log non compaia la stringa “Installazione driver I2S fallita”.
Il suono è molto basso, quasi inudibile
Per prima cosa conferma l’impedenza dell’altoparlante. Con un altoparlante da 4Ω il MAX98357A eroga 3W, con uno da 8Ω solo circa 1.4W: il volume si dimezza. Poi controlla che il VIN sia collegato a 5V: a 3.3V la potenza cala drasticamente. Puoi anche alzare nel codice PCM_OUTPUT_SCALE da 26000 a 30000, ma senza superare 32767, oltre vai in overflow e in distorsione.
La direzione di rotazione dell’encoder è invertita (orario diminuisce, antiorario aumenta)
In encoderISR() scambia encoderPosition++ con encoderPosition--, oppure scambia direttamente i collegamenti fisici di CLK e DT: scegli una delle due.
Subito dopo l’accensione va in crash e si riavvia, la seriale mostra Stack canary watchpoint triggered
È l’overflow dello stack di uno dei task FreeRTOS; il messaggio di errore riporta il nome del task (ad esempio Monitor). Trova il task corrispondente e aumenta la dimensione dello stack nel xTaskCreatePinnedToCore (il terzo numero): il task Monitor richiede almeno 4096, se non basta metti 8192.
La seriale mostra OOM: failed to allocate XXX bytes
Overflow di memoria. Verifica in questo ordine:
- In Arduino IDE, Strumenti → PSRAM deve essere selezionato, e deve essere QSPI PSRAM (non OPI)
- Aggiungi all’inizio di
setup()la rigaSerial.printf("PSRAM: %d\n", ESP.getFreePsram());, riflasha e guarda la seriale: se stampa 0 significa che la PSRAM non è stata attivata, torna a correggere l’opzione - Conferma che il modello della tua scheda abbia la PSRAM esterna (in ESP32-S3-WROOM-1-N16R8 la R8 indica proprio 8MB di PSRAM)
Nel suono ci sono clic o rumore a intervalli regolari
Nella maggior parte dei casi è un problema di massa comune. Il GND dell’ESP32-S3 e il GND del MAX98357A devono essere collegati allo stesso filo, non a due masse separate di alimentatori diversi. Con un multimetro misura la resistenza tra i due GND: dovrebbe essere vicina a 0Ω.
FAQ
D: I GPIO16/17/15 dell’ESP32-S3 sono occupati, posso usare altri pin?
R: Sì, i pin I2S possono essere mappati liberamente su qualsiasi GPIO. Modifica le tre macro I2S_BCLK, I2S_LRC, I2S_DOUT in cima al codice con i numeri di pin che vuoi usare. Tieni però presente che GPIO 0, 1, 2, 3, 43, 44 hanno usi speciali, meglio evitarli.
D: Posso collegare due altoparlanti per fare lo stereo?
R: Il MAX98357A è un amplificatore mono; per lo stereo servono due moduli, uno sul canale sinistro e uno sul destro, distinguibili tramite il collegamento del pin GAIN (uno collegato a GND = canale destro, uno flottante = canale sinistro). Nel codice i due canali PCM sono attualmente uguali (stereoBuffer[i*2] = stereoBuffer[i*2+1] = out); per uno stereo reale va modificata anche la logica di sintesi.
D: La frequenza di campionamento di 22050Hz basta? Posso passare a 44100Hz?
R: 22050Hz è più che sufficiente per contenuti medio-gravi come il suono di un motore: riesce a ricostruire fino a 11025Hz, e la percezione umana del rombo del motore si concentra soprattutto tra 50Hz e 4kHz. In teoria si può passare a 44100Hz, ma il carico sulla CPU raddoppia: conviene prima verificare la stabilità, modificando in modo coerente SAMPLE_RATE e il campo sample_rate della configurazione I2S.
D: Collegando l’alimentazione a 5V rischio di bruciare l’ESP32-S3? R: Il VIN del MAX98357A va a 5V, ma i suoi pin di segnale (BCLK, LRC, DIN) lavorano a 3.3V e possono essere collegati direttamente ai GPIO dell’ESP32-S3, senza conversione di livello. I GPIO dell’ESP32-S3 erogano 3.3V e il MAX98357A li riconosce: sicuro.
D: Il suono al minimo è troppo basso, non si sente bene, posso alzarlo?
R: Regola BACKGROUND_GAIN_IDLE (default 0.45) e THUMP_LAYER_GAIN_IDLE (default 0.75), alzali entrambi, ad esempio a 0.6 e 1.0: il volume al minimo aumenterà in modo evidente. Dopo la modifica ricordati di verificare che a acceleratore massimo non ci sia clipping; in caso, abbassa leggermente PCM_OUTPUT_SCALE.
D: L’encoder KY-040 a ogni scatto varia l’acceleratore del 10%, è troppo, posso renderlo più fine?
R: Riduci ENCODER_STEP_SIZE da 0.1 a, ad esempio, 0.05: diventerà il 5% per scatto e serviranno 20 scatti per arrivare al massimo, con sensibilità più fine.
D: Il programma può girare su ESP32 (non S3)? R: In teoria sì, l’API I2S è standard, ma i normali ESP32 non hanno PSRAM esterna o ne hanno poca: questo progetto potrebbe rimanere senza memoria. Ti consiglio almeno un modello con PSRAM, ad esempio ESP32-WROVER. Anche i numeri dei GPIO vanno rimappati in base alla tua scheda.
Estensioni
Dopo la versione base, puoi espandere il progetto in queste direzioni:
- Collega un sensore di velocità: monta un sensore di Hall sulla ruota; più la velocità è alta, più l’acceleratore sale automaticamente, a mani libere
- Cambia in V6 / 4 cilindri in linea / suono moto: modifica
NUM_CYLINDERSefiringAngles, con un’altra serie di angoli di accensione ottieni un motore diverso - Aggiungi uno schermo TFT: visualizza il contagiri e la percentuale di acceleratore, per un effetto cruscotto
- Aggiungi un involucro impermeabile: per l’uso su un veicolo elettrico, anche sotto la pioggia serve un’impermeabilizzazione curata, altrimenti l’acqua dentro al circuito è un problema peggiore del silenzio