// will play many audio file formats, mp3,aac,flac etc.
// See github page : [Link]
#include "Arduino.h"
#include "Audio.h"
#include "SD.h"
#include "FS.h"
// Digital I/O used
#define SD_CS 5
#define SPI_MOSI 23 // SD Card
#define SPI_MISO 19
#define SPI_SCK 18
#define I2S_DOUT 25
#define I2S_BCLK 27 // I2S
#define I2S_LRC 26
#define REC_BUTTON 21
#define PLAY_BUTTON 4
#define MIC_PIN 32
#define SAMPLE_RATE 8000
size_t byteCounter = 0;
uint32_t fileSize;
uint16_t sampleNum = 0, samplesWritten = 0, samplesArray16[128], sampleRead16;
uint8_t samplesArray8[256];
uint8_t samplesRead8[2];
bool isRecording = true, isPlaying = false, alternator = false;
char fileName[] = "/[Link]";
Audio audio1, audio2;
File audioFile, bufferFile;
void setup() {
pinMode(REC_BUTTON, INPUT_PULLUP);
pinMode(PLAY_BUTTON, INPUT_PULLUP);
//pinMode(SD_CS, OUTPUT);
//digitalWrite(SD_CS, HIGH);
//[Link](SPI_SCK, SPI_MISO, SPI_MOSI);
[Link](9600);
delay(1000);
if () {
[Link]("SD card initialization failed.");
return;
}
[Link]("SD card initialized.");
audioFile = [Link]("/[Link]", FILE_WRITE);
if (!audioFile) {
[Link]("Failed to open WAV file for writing.");
return;
}
[Link]("WAV file opened successfuly.");
bufferFile = [Link]("/[Link]");
if (!bufferFile) {
[Link]("Failed to open Text buffer file for writing.");
return;
}
[Link]("TEXT file opened successfuly.");
writeWavHeader(audioFile);
[Link]();
[Link](I2S_BCLK, I2S_LRC, I2S_DOUT);
[Link](21);
}
void loop() {
if (isRecording) {
uint16_t micValue = analogRead(MIC_PIN);
samplesArray16[sampleNum] = micValue;
sampleNum++;
if (sampleNum == 128) {
for (int i = 0; i < 128; i++) {
samplesArray8[i * 2] = (uint8_t)((samplesArray16[i] & 0xFF00) >> 8);
samplesArray8[i * 2 + 1] = (uint8_t)(samplesArray16[i] & 0x00FF);
}
[Link](samplesArray8, 256);
memset(samplesArray16, 0, sizeof(samplesArray16));
sampleNum = 0;
}
samplesWritten++;
}
if (digitalRead(REC_BUTTON) == LOW && isRecording) {
delay(50);
if (digitalRead(REC_BUTTON) == LOW) {
[Link]("Recording stopped!");
isRecording = false;
audioFile = [Link]("/[Link]", FILE_WRITE);
for(int i = 0; i < samplesWritten; i++) {
[Link](samplesRead8, 2);
sampleRead16 = ((uint16_t)samplesRead8[1] << 8) | samplesRead8[0];
writeSample(audioFile, sampleRead16);
}
[Link]();
headerSizeFiller();
[Link]();
fileSizePrinter();
[Link]("Bytes written: " + String(byteCounter));
}
}
if (digitalRead(PLAY_BUTTON) == LOW && !isPlaying) {
delay(50);
if (digitalRead(PLAY_BUTTON == LOW)) {
isPlaying = true;
[Link]("Button pressed. Playing audio...");
playAudio();
}
}
}
void playAudio() {
[Link](SD, "/[Link]");
while(true) {
[Link](30000000, 2);
if (digitalRead(PLAY_BUTTON) == LOW && isPlaying) {
delay(1000);
if (digitalRead(PLAY_BUTTON == LOW)) {
isPlaying = true;
[Link]("Button pressed. Playing audio...");
playAudio();
}
}
}
/*uint8_t buf[4];
int16_t buf16[2];
size_t bytes_read;
while(true) {
bytes_read = [Link](buf, 4);
//convertArray(buf, buf16, 2);
buf16[0] = (buf[1] << 8) | buf[0];
buf16[1] = (buf[3] << 8) | buf[2];
[Link](buf16);
buf16[0] = ((buf16[0] & 0xff) - 128) << 8;
buf16[1] = ((buf16[1] & 0xff) - 128) << 8;
}*/
}
void writeSample(File &file, uint16_t sample) {
// Ensure sample is within the range of a 12-bit signed integer
sample = constrain(sample, -2048, 2047);
// Convert 12-bit sample to 16-bit format for WAV file (left-justified)
uint16_t sample16 = sample & 0xFFF; // Use lower 12 bits
// Write a 16-bit sample to the WAV file
uint8_t bytes[2];
bytes[0] = sample16 & 0xFF; // Least significant byte
bytes[1] = (sample16 >> 8) & 0xFF; // Most significant byte
[Link](bytes, 2); // Return the number of bytes written
byteCounter += 2;
}
void fileSizePrinter() {
audioFile = [Link]("/[Link]", FILE_READ);
fileSize = [Link]();
[Link]("File size: " + String(fileSize));
[Link]();
}
void headerSizeFiller() {
[Link](4);
[Link]((uint8_t*)&fileSize, 4); // File size placeholder
[Link](40);
[Link]((uint8_t*)&byteCounter, 4); // File size placeholder
void writeWavHeader(File &file) {
// Write WAV file header
const char fileSizeH[] = "----";
const char dataSize[] = "----";
const char riffHeader[] = "RIFF";
[Link]((const uint8_t*)riffHeader, 4); // RIFF header
[Link]((uint8_t*)&fileSizeH, 4); // File size placeholder
const char waveHeader[] = "WAVE";
[Link]((const uint8_t*)waveHeader, 4); // WAV format
const char fmtHeader[] = "fmt ";
[Link]((const uint8_t*)fmtHeader, 4); // Format chunk
uint32_t fmtSize = 16;
[Link]((uint8_t*)&fmtSize, 4); // Format chunk size
uint16_t audioFormat = 1; // PCM format
[Link]((uint8_t*)&audioFormat, 2); // Audio format
uint16_t numChannels = 1; // Mono
[Link]((uint8_t*)&numChannels, 2); // Number of channels
uint32_t sampleRate = SAMPLE_RATE; // Sample rate
[Link]((uint8_t*)&sampleRate, 4); // Sample rate
uint32_t byteRate = sampleRate * numChannels * (16 / 8); // Byte rate
[Link]((uint8_t*)&byteRate, 4); // Byte rate
uint16_t blockAlign = numChannels * (16 / 8); // Block align
[Link]((uint8_t*)&blockAlign, 2); // Block align
uint16_t bitsPerSample = 16; // Bits per sample
[Link]((uint8_t*)&bitsPerSample, 2); // Bits per sample
const char dataHeader[] = "data";
[Link]((const uint8_t*)dataHeader, 4); // Data chunk
[Link]((uint8_t*)&dataSize, 4); // Data size placeholder
}