/** * BikeAudio — Boards B & C : I2S SLAVE -> [touch-adjustable delay] -> A2DP SOURCE * * Reads PCM from the shared I2S bus (clocked by Board A), passes it through an * adjustable delay line, and streams it to ONE Bluetooth speaker. The delay lets * you sync this speaker against the other one, tuned live BY EAR with two * capacitive-touch pads (+ / -). The value is saved to flash (survives reboots). * * No Wi-Fi: Wi-Fi + Bluetooth-A2DP + the audio buffer don't fit in RAM on this * chip (the BT stack gets starved and won't connect), so the control is local * touch rather than a phone UI. With Wi-Fi gone there's ~120 KB of heap free. * * Per-env build flag: TARGET_SPEAKER ("JBL Charge 5" / "Tangerine EDGE"). * * Wiring: * I2S in (from Board A): BCK=GPIO19 WS=GPIO18 DATA=GPIO22 + GND * Touch "+" : GPIO4 (T0) Touch "-" : GPIO27 (T7) * (attach a short wire or a bit of foil to each; tap = one step, hold = ramp) */ #include #include "AudioTools.h" #include "BluetoothA2DPSource.h" #include #ifndef TARGET_SPEAKER #define TARGET_SPEAKER "BikeAudio-Speaker" #endif #define I2S_BCK_PIN 19 #define I2S_WS_PIN 18 #define I2S_DATA_PIN 22 #define TOUCH_PLUS T0 // GPIO4 #define TOUCH_MINUS T7 // GPIO27 #define TOUCH_THRESH 40 // touchRead below this = touched (calibrate via serial) #define SR_HZ 44100 #define MAX_DELAY_MS 200 #define DELAY_STEP_MS 5 #define TOUCH_REPEAT_MS 150 // tap = one step; hold = a step every 150 ms #define RING_FRAMES (((uint32_t)SR_HZ * (MAX_DELAY_MS + 20)) / 1000) I2SStream i2s; BluetoothA2DPSource source; Preferences prefs; static int16_t ring[RING_FRAMES * 2]; static volatile uint32_t write_frames = 0; static volatile uint32_t delay_frames = 0; static volatile uint16_t delay_ms_current = 0; static bool save_pending = false; static unsigned long last_change_ms = 0; // Continuously pull I2S into the ring (paced by Board A's clock). static void i2s_task(void *arg) { static int16_t tmp[256 * 2]; for (;;) { size_t bytes = i2s.readBytes((uint8_t *)tmp, sizeof(tmp)); int frames = bytes / 4; for (int i = 0; i < frames; i++) { uint32_t w = write_frames % RING_FRAMES; ring[w * 2] = tmp[i * 2]; ring[w * 2 + 1] = tmp[i * 2 + 1]; write_frames++; } if (frames == 0) vTaskDelay(1); // no clock yet (Board A down) — don't spin } } // A2DP pulls frames; serve them delayed by delay_frames behind the write head. int32_t read_delayed(Frame *data, int32_t frame_count) { uint32_t d = delay_frames; if (d < (uint32_t)frame_count) d = frame_count; // never read past the write head uint32_t w = write_frames; if (w < d) { for (int32_t i = 0; i < frame_count; i++) { data[i].channel1 = 0; data[i].channel2 = 0; } return frame_count; } uint32_t start = w - d; for (int32_t i = 0; i < frame_count; i++) { uint32_t idx = (start + i) % RING_FRAMES; data[i].channel1 = ring[idx * 2]; data[i].channel2 = ring[idx * 2 + 1]; } return frame_count; } static void set_delay(int ms) { if (ms < 0) ms = 0; if (ms > MAX_DELAY_MS) ms = MAX_DELAY_MS; if ((uint16_t)ms == delay_ms_current) return; delay_ms_current = (uint16_t)ms; delay_frames = ((uint32_t)ms * SR_HZ) / 1000; save_pending = true; last_change_ms = millis(); Serial.printf("[SRC %s] delay = %d ms\n", TARGET_SPEAKER, ms); } void on_conn_state(esp_a2d_connection_state_t state, void *obj) { if (state == ESP_A2D_CONNECTION_STATE_CONNECTED) Serial.printf("[SRC %s] CONNECTED\n", TARGET_SPEAKER); else if (state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) Serial.printf("[SRC %s] disconnected — will retry\n", TARGET_SPEAKER); } void setup() { Serial.begin(115200); delay(500); Serial.printf("=== BikeAudio Source -> '%s' (touch-adjustable delay) ===\n", TARGET_SPEAKER); prefs.begin("bikeaudio", false); set_delay(prefs.getUShort("delay_ms", 0)); save_pending = false; // loading isn't a change to persist // I2S slave RX — follows Board A's clock. auto cfg = i2s.defaultConfig(RX_MODE); cfg.pin_bck = I2S_BCK_PIN; cfg.pin_ws = I2S_WS_PIN; cfg.pin_data = I2S_DATA_PIN; cfg.sample_rate = SR_HZ; cfg.channels = 2; cfg.bits_per_sample = 16; cfg.is_master = false; cfg.buffer_count = 8; cfg.buffer_size = 512; i2s.begin(cfg); xTaskCreatePinnedToCore(i2s_task, "i2s_reader", 4096, nullptr, 5, nullptr, 0); source.set_data_callback_in_frames(read_delayed); source.set_on_connection_state_changed(on_conn_state); source.set_auto_reconnect(true, 5); source.set_volume(100); source.start(TARGET_SPEAKER); Serial.printf("[SRC] Connecting to '%s' — delay %u ms; touch + on GPIO4, - on GPIO27\n", TARGET_SPEAKER, delay_ms_current); } void loop() { unsigned long now = millis(); // Touch +/- (tap = one step, hold = ramp every TOUCH_REPEAT_MS). static unsigned long last_touch = 0; if (now - last_touch >= TOUCH_REPEAT_MS) { bool plus = touchRead(TOUCH_PLUS) < TOUCH_THRESH; bool minus = touchRead(TOUCH_MINUS) < TOUCH_THRESH; if (plus && !minus) { set_delay(delay_ms_current + DELAY_STEP_MS); last_touch = now; } else if (minus && !plus) { set_delay(delay_ms_current - DELAY_STEP_MS); last_touch = now; } } // Persist to flash 1.5 s after the last change (avoids wear while ramping). if (save_pending && now - last_change_ms > 1500) { prefs.putUShort("delay_ms", delay_ms_current); save_pending = false; Serial.printf("[SRC %s] saved %u ms to flash\n", TARGET_SPEAKER, delay_ms_current); } static unsigned long last_st = 0; if (now - last_st > 5000) { Serial.printf("[SRC %s] connected=%s delay=%ums heap=%u touch+=%u touch-=%u\n", TARGET_SPEAKER, source.is_connected() ? "YES" : "no", delay_ms_current, ESP.getFreeHeap(), touchRead(TOUCH_PLUS), touchRead(TOUCH_MINUS)); last_st = now; } delay(20); }