Front view of the audio time capsule, using Koss Porta Pro headphones as audio output.

Plugged in, audio playing in use.

/*

 Audio Time Capsule — Adafruit Feather RP2040 + VS1053b breakout

 by Viviana Staicu

AI was used to support the making of this project's code using Opus 4.6 via Cursor.

 On boot: plays the first audio file (.OGG/.MP3/.WAV) found on the SD card

          through LOUT / ROUT / AGND on the VS1053b.

 Buttons:

   GPIO 7 — pause / resume playback (some boards print “5” near this pin; use the

            RP2040 GPIO number, not the silk text alone)

   D13    — toggle recording on/off (armed only after boot delay — see below)

 OLED 128×64 (I2C, 4-pin: VCC GND SDA SCL):

   VCC → 3V  (Feather is 3.3 V logic; use 3V unless your module docs say 5 V only)

   GND → GND

   SDA → SDA   (GPIO 2 on Feather RP2040)

   SCL → SCL   (GPIO 3)

 Wiring (Feather RP2040 → VS1053b breakout):

   XCS  → D11       VS1053 command chip-select

   XDCS → D10       VS1053 data chip-select

   DREQ → D12       VS1053 data-request (high = ready)

   SDCS → D9        SD card chip-select on the VS1053 breakout

   SPI  → SCK / MO / MI  (hardware SPI0)

   XRST → not connected (breakout pull-up keeps it high)

   Audio out: LOUT, ROUT, AGND → 3.5 mm jack

 Volume pot (0–100 % loudness):

   Wiper → an **ADC** pin only: A0 (GP26), A1 (GP27), A2 (GP28), or A3 (GP29).

   The silk “D8” / GPIO8 pin has **no** analog input on Feather RP2040 — if you

   wired the wiper there, move it to A0 (or A1–A3) and set VOLUME_POT_PIN below.

   Ends of pot: 3V3 and GND.

 SD card must contain:

   v44k1q05.img     (VS1053 OGG recording plugin — copy from

                     Adafruit_VS1053_Library/examples/record_ogg/)

 Libraries: Adafruit VS1053, SD, Adafruit NeoPixel, Wire, Adafruit GFX, Adafruit SSD1306

   (Recording: NeoPixel blinks red. Playback: smooth rainbow loop while audio plays.)

*/

#include <SPI.h>

#include <Wire.h>

#include <SD.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#include <Adafruit_VS1053.h>

#include <Adafruit_NeoPixel.h>

// I2C OLED 128×64 (SSD1306). If the screen stays black, try OLED_I2C_ADDR 0x3D.

#define OLED_I2C_ADDR   0x3C

#define OLED_WIDTH      128

#define OLED_HEIGHT     64

Adafruit_SSD1306 oled(OLED_WIDTH, OLED_HEIGHT, &Wire, -1);

bool oledOk = false;

unsigned long lastOledPaintMs = 0;

const unsigned long OLED_PAINT_MS = 250;

// Feather RP2040 onboard NeoPixel: data on GPIO17, power gated on GPIO16

#ifndef PIN_NEOPIXEL

#define PIN_NEOPIXEL 17

#endif

#ifndef NEOPIXEL_POWER

#define NEOPIXEL_POWER 16  // Feather RP2040: high = NeoPixel supply on

#endif

Adafruit_NeoPixel statusPixel(1, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);

unsigned long recBlinkLastMs = 0;

bool recBlinkOn = false;

const unsigned long REC_BLINK_MS = 350;

// NeoPixel ambient rainbow while playing (HSV hue 0…65535)

uint16_t ambientHue = 0;

unsigned long ambientLastMs = 0;

const unsigned long AMBIENT_MIN_STEP_MS = 22;

const unsigned long AMBIENT_FULL_CYCLE_MS = 16000;  // ms for one full hue loop

static bool playbackAmbientLedOn = false;

// ── Pin definitions ──────────────────────────────────────────────────

#define VS1053_CS      11

#define VS1053_DCS     10

#define VS1053_DREQ    12

#define VS1053_RESET   -1

#define CARDCS          9

#define REC_BUTTON     13   // record start/stop

#define PLAY_BUTTON     7   // pause/resume (silk may say “5”; this board uses GPIO 7)

// Analog volume: only A0–A3 work on Feather RP2040 (not GPIO8/D8).

#define VOLUME_POT_PIN  A0

// Ignore record button until this time (ms) — avoids accidental start at power-up

const unsigned long RECORD_ARM_MS = 3500;

unsigned long recordEnabledAtMs = 0;

// ── VS1053 FilePlayer (inherits recording methods too) ───────────────

Adafruit_VS1053_FilePlayer player(VS1053_RESET, VS1053_CS, VS1053_DCS,

                                 VS1053_DREQ, CARDCS);

// ── Recording state ──────────────────────────────────────────────────

File recordingFile;

bool isRecording = false;

uint8_t recording_buffer[512];

char recpath[20];

int recNum = 1;

// ── Playback state ───────────────────────────────────────────────────

char playfile[13];

bool foundPlayFile = false;

// ── Button debounce ──────────────────────────────────────────────────

bool lastRecBtn  = HIGH;

bool lastPlayBtn = HIGH;

unsigned long lastRecDebounce  = 0;

unsigned long lastPlayDebounce = 0;

const unsigned long DEBOUNCE_MS = 300;

// VS1053 setVolume: 0 = loudest, 255 ≈ mute — map pot 0…100 % → atten 255…0

const int         ADC_FULL        = 4095;  // after analogReadResolution(12)

const uint8_t     VOLUME_HYST     = 2;     // ignore tiny jitter (in raw atten steps)

const unsigned long VOLUME_POLL_MS = 20;

static int        lastVolAtten    = -1;

static unsigned long lastVolPoll  = 0;

void updateVolumeFromPot() {

 if (millis() - lastVolPoll < VOLUME_POLL_MS)

   return;

 lastVolPoll = millis();

 uint32_t sum = 0;

 for (uint8_t i = 0; i < 4; i++)

   sum += analogRead(VOLUME_POT_PIN);

 int raw = (int)(sum / 4);

 // 0 % = mute (255), 100 % = full level (0)

 int atten = map(raw, 0, ADC_FULL, 255, 0);

 atten = constrain(atten, 0, 255);

 if (lastVolAtten < 0 || abs(atten - lastVolAtten) >= VOLUME_HYST) {

   lastVolAtten = atten;

   player.setVolume((uint8_t)atten, (uint8_t)atten);

 }

}

// ── Find the first playable file on the SD root ──────────────────────

bool findFirstAudioFile() {

 File root = SD.open("/");

 if (!root) return false;

 while (true) {

   File entry = root.openNextFile();

   if (!entry) break;

   if (entry.isDirectory()) { entry.close(); continue; }

   const char *name = entry.name();

   size_t len = strlen(name);

   if (len > 4) {

     const char *ext = name + len - 4;

     if (strcasecmp(ext, ".ogg") == 0 ||

         strcasecmp(ext, ".mp3") == 0 ||

         strcasecmp(ext, ".wav") == 0) {

       strncpy(playfile, name, sizeof(playfile) - 1);

       playfile[sizeof(playfile) - 1] = '\0';

       entry.close();

       root.close();

       return true;

     }

   }

   entry.close();

 }

 root.close();

 return false;

}

// ── Recording helpers ────────────────────────────────────────────────

void findNextRecFilename() {

 while (recNum < 10000) {

   snprintf(recpath, sizeof(recpath), "REC%04d.OGG", recNum);

   if (!SD.exists(recpath)) return;

   recNum++;

 }

}

void startRecording() {

 if (player.playingMusic || player.paused()) {

   player.stopPlaying();

   Serial.println("Playback stopped for recording.");

 }

 player.softReset();

 delay(100);

 findNextRecFilename();

 if (SD.exists(recpath)) SD.remove(recpath);

 recordingFile = SD.open(recpath, FILE_WRITE);

 if (!recordingFile) {

   Serial.print("[ERR] Could not open ");

   Serial.println(recpath);

   return;

 }

 if (!player.prepareRecordOgg((char *)"v44k1q05.img")) {

   Serial.println("[ERR] OGG plugin load failed — is v44k1q05.img on the SD root?");

   recordingFile.close();

   return;

 }

 player.startRecordOgg(true);

 isRecording = true;

 recBlinkLastMs = millis();

 recBlinkOn = true;

 statusPixel.setPixelColor(0, statusPixel.Color(255, 0, 0));

 statusPixel.show();

 Serial.print("** RECORDING → ");

 Serial.print(recpath);

 Serial.println(" — press D13 to stop **");

 paintOled();

}

void stopRecording() {

 player.stopRecordOgg();

 flushRecordingData();

 recordingFile.close();

 isRecording = false;

 statusPixel.clear();

 statusPixel.show();

 recNum++;

 Serial.print("Saved ");

 Serial.println(recpath);

 player.softReset();

 delay(100);

 // Recording / OGG plugin raised CLOCKF to 0xC000 — decoder needs 0x6000 again

 player.sciWrite(VS1053_REG_CLOCKF, 0x6000);

 delay(10);

 lastVolAtten = -1;

 lastVolPoll = 0;  // bypass throttle so volume applies immediately

 updateVolumeFromPot();

 Serial.println("Ready. GPIO7 = play, D13 = record, pot = volume.");

 paintOled();

}

void flushRecordingData() {

 uint16_t wordsWaiting = player.recordedWordsWaiting();

 while (wordsWaiting > 256) {

   for (int i = 0; i < 256; i++) {

     uint16_t w = player.recordedReadWord();

     recording_buffer[i * 2]     = w >> 8;

     recording_buffer[i * 2 + 1] = w & 0xFF;

   }

   recordingFile.write(recording_buffer, 512);

   wordsWaiting -= 256;

 }

}

// ── Playback helpers ─────────────────────────────────────────────────

void beginPlayback() {

 player.stopPlaying();  // clear SM_CANCEL, close any stale file handle

 delay(20);

 foundPlayFile = findFirstAudioFile();

 if (!foundPlayFile) {

   Serial.println("No .OGG/.MP3/.WAV on SD root (v44k1q05.img alone won't play).");

   Serial.println("Copy a music file to the card for auto-play, or use D13 to record.");

   paintOled();

   return;

 }

 player.sciWrite(VS1053_REG_CLOCKF, 0x6000);

 delay(10);

 Serial.print("Playing: ");

 Serial.println(playfile);

 if (!player.startPlayingFile(playfile)) {

   Serial.println("[ERR] startPlayingFile failed — check filename / SD.");

 }

 paintOled();

}

// ── Button edge detectors ────────────────────────────────────────────

bool recButtonPressed() {

 bool state = digitalRead(REC_BUTTON);

 if (state == LOW && lastRecBtn == HIGH &&

     (millis() - lastRecDebounce > DEBOUNCE_MS)) {

   lastRecDebounce = millis();

   lastRecBtn = state;

   return true;

 }

 lastRecBtn = state;

 return false;

}

bool playButtonPressed() {

 bool state = digitalRead(PLAY_BUTTON);

 if (state == LOW && lastPlayBtn == HIGH &&

     (millis() - lastPlayDebounce > DEBOUNCE_MS)) {

   lastPlayDebounce = millis();

   lastPlayBtn = state;

   return true;

 }

 lastPlayBtn = state;

 return false;

}

void updateAmbientPlaybackLed() {

 unsigned long now = millis();

 unsigned long dt = now - ambientLastMs;

 if (dt < AMBIENT_MIN_STEP_MS)

   return;

 ambientLastMs = now;

 ambientHue += (uint16_t)((65536UL * dt) / AMBIENT_FULL_CYCLE_MS);

 // Slightly soft saturation so colors feel “ambient” vs full neon

 statusPixel.setPixelColor(0, statusPixel.ColorHSV(ambientHue, 210, 255));

 statusPixel.show();

}

void paintOled() {

 if (!oledOk)

   return;

 oled.clearDisplay();

 oled.setTextSize(1);

 oled.setTextColor(SSD1306_WHITE);

 oled.setCursor(0, 0);

 if (isRecording) {

   oled.println(F("RECORDING"));

   oled.println(recpath);

 } else if (!foundPlayFile) {

   oled.println(F("No audio file"));

   oled.println(F("on SD root"));

 } else if (player.paused()) {

   oled.println(F("PAUSED"));

   oled.println(playfile);

 } else if (player.playingMusic) {

   oled.println(F("PLAYING"));

   oled.println(playfile);

 } else {

   oled.println(F("STOPPED"));

   oled.println(playfile);

 }

 oled.setCursor(0, 56);

 oled.print(F("Vol "));

 if (lastVolAtten >= 0) {

   int pct = map(lastVolAtten, 255, 0, 0, 100);

   oled.print(pct);

   oled.println(F("%"));

 } else {

   oled.println(F("--"));

 }

 oled.display();

}

// ═════════════════════════════════════════════════════════════════════

void setup() {

 Serial.begin(115200);

 unsigned long t0 = millis();

 while (!Serial && millis() - t0 < 3000) { delay(10); }

 Serial.println("\n==========================================");

 Serial.println(" OGG RECORDER + PLAYER — Feather RP2040");

 Serial.println("==========================================");

 pinMode(REC_BUTTON,  INPUT_PULLUP);

 pinMode(PLAY_BUTTON, INPUT_PULLUP);

 analogReadResolution(12);

 if (!player.begin()) {

   Serial.println("VS1053 failed! Check wiring.");

   while (1) delay(100);

 }

 Serial.println("VS1053 OK");

 // FilePlayer.begin() does NOT mount the SD card — Adafruit examples always

 // call SD.begin() separately after the codec is up.

 if (!SD.begin(CARDCS)) {

   Serial.println("SD card failed — insert FAT32 card, check SDCS wiring.");

   while (1) delay(100);

 }

 Serial.println("SD card OK");

 Wire.begin();

 oledOk = oled.begin(SSD1306_SWITCHCAPVCC, OLED_I2C_ADDR);

 if (!oledOk)

   Serial.println("OLED not found — check I2C wiring / try OLED_I2C_ADDR 0x3D.");

 else {

   oled.clearDisplay();

   oled.display();

   Serial.println("OLED OK");

 }

 lastVolAtten = -1;

 updateVolumeFromPot();

 // DREQ interrupts + shared SPI on RP2040 often starve SD reads — poll feedBuffer

 // in loop() instead (no useInterrupt).

 beginPlayback();

 recordEnabledAtMs = millis() + RECORD_ARM_MS;

 delay(50);

 lastRecBtn  = digitalRead(REC_BUTTON);

 lastPlayBtn = digitalRead(PLAY_BUTTON);

 Serial.println("\nGPIO7 = pause / resume playback");

 Serial.println("D13   = start / stop recording (enabled after boot delay)");

#if defined(NEOPIXEL_POWER)

 pinMode(NEOPIXEL_POWER, OUTPUT);

 digitalWrite(NEOPIXEL_POWER, HIGH);

#endif

 statusPixel.begin();

 statusPixel.setBrightness(40);

 statusPixel.clear();

 statusPixel.show();

 ambientLastMs = millis();

}

void loop() {

 updateVolumeFromPot();

 // ── Record button (D13) — stop always allowed; start only after boot arm ──

 if (recButtonPressed()) {

   if (!isRecording) {

     if (millis() < recordEnabledAtMs)

       ; // still booting — do not start recording

     else

       startRecording();

   } else {

     stopRecording();

   }

 }

 // ── Play/pause (GPIO7) — ignored while recording ───────────────

 if (!isRecording && playButtonPressed()) {

   if (player.playingMusic) {

     player.pausePlaying(true);

     Serial.println("Paused.");

     paintOled();

   } else if (player.paused()) {

     player.pausePlaying(false);

     Serial.println("Resumed.");

     paintOled();

   } else {

     // stopped() after track ended — not paused(); start fresh scan + play

     beginPlayback();

   }

 }

 // ── Feed playback (polling — required on RP2040 without DREQ IRQ) ──

 if (!isRecording && player.playingMusic) {

   player.feedBuffer();

 }

 // ── NeoPixel: recording blink / playback rainbow / off when idle ──

 if (isRecording) {

   playbackAmbientLedOn = false;

   flushRecordingData();

   unsigned long now = millis();

   if (now - recBlinkLastMs >= REC_BLINK_MS) {

     recBlinkLastMs = now;

     recBlinkOn = !recBlinkOn;

     if (recBlinkOn)

       statusPixel.setPixelColor(0, statusPixel.Color(255, 0, 0));

     else

       statusPixel.setPixelColor(0, 0);

     statusPixel.show();

   }

 } else if (player.playingMusic && !player.paused()) {

   updateAmbientPlaybackLed();

   playbackAmbientLedOn = true;

 } else {

   if (playbackAmbientLedOn) {

     statusPixel.clear();

     statusPixel.show();

     playbackAmbientLedOn = false;

   }

 }

 if (oledOk && millis() - lastOledPaintMs >= OLED_PAINT_MS) {

   lastOledPaintMs = millis();

   paintOled();

 }

}