How would I go about making a Voice Recording and Playback device (INMP 441 to DFPlayerMini)

[vertigoooooooo]

Hey there, fairly new to coding but been trying to wrap my head around this sorta stuff for a very imminent uni project. I have been struggling to get i2s drivers to work on previous code and came across a video from Andreas talking about this miracle library! I was wondering how I would create a code that allows me to systematically record and save files onto an sd card I have in my DFPlayerMini module, and then would be able to play them back. I will attach the code below to show where I got up to before coming across this. Any help would be so appreciated as I am short for time to properly learn all the ins and outs myself. Amazing work Phil!

`#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
#include <SD.h>
#include <driver/i2s.h>

// Use pins 2 and 3 to communicate with DFPlayer Mini
static const uint8_t PIN_MP3_TX = 27; // D7
static const uint8_t PIN_MP3_RX = 26; // D6
static const uint8_t ROTARY_ENCODER_CLK = 23; // Rotary encoder CLK pin
static const uint8_t ROTARY_ENCODER_DT = 22; // Rotary encoder DT pin
static const uint8_t ROTARY_ENCODER_SW = 35; // Rotary encoder switch pin

static const uint8_t MIC_BCK_PIN = 15; // BCK pin for microphone
static const uint8_t MIC_WS_PIN = 2; // WS pin for microphone
static const uint8_t MIC_DATA_PIN = 4; // DATA pin for microphone

SoftwareSerial softwareSerial(PIN_MP3_RX, PIN_MP3_TX);
DFRobotDFPlayerMini player;

volatile bool buttonPressed = false;
volatile int currentFileIndex = 1; // Current index of selected audio file

int lastEncoderPosition = 0; // Last known position of the rotary encoder

enum Mode { PLAY, RECORD };
Mode currentMode = PLAY;

void setup() {
Serial.begin(19200);
delay(500);
Serial.print("\r\n\r\nhwserial\r\nok\r\n");
delay(500);
softwareSerial.begin(9600);
delay(3000);

pinMode(ROTARY_ENCODER_CLK, INPUT_PULLUP);
pinMode(ROTARY_ENCODER_DT, INPUT_PULLUP);
pinMode(ROTARY_ENCODER_SW, INPUT_PULLUP);

if (!SD.begin()) {
Serial.println("SD initialization failed!");
return;
}

if (player.begin(softwareSerial)) {
Serial.println("OK");
player.volume(20); //30 is very loud
} else {
Serial.println("Connecting to DFPlayer Mini failed!");
}

// Initialize I2S interface for microphone
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX), // Receive mode
.sample_rate = 16000, // Sample rate (Hz)
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT, // Bits per sample
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // Mono
.communication_format = I2S_COMM_FORMAT_I2S_MSB,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // Interrupt level 1
.dma_buf_count = 8,
.dma_buf_len = 64,
.use_apll = false,
.tx_desc_auto_clear = false,
.fixed_mclk = 0};
i2s_pin_config_t pin_config = {
.bck_io_num = MIC_BCK_PIN,
.ws_io_num = MIC_WS_PIN,
.data_out_num = -1, // Not used in RX mode
.data_in_num = MIC_DATA_PIN};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
i2s_set_pin(I2S_NUM_0, &pin_config);

attachInterrupt(digitalPinToInterrupt(ROTARY_ENCODER_SW), buttonInterrupt, FALLING);
}

void loop() {
// Switch between modes
switchModes();

if (currentMode == RECORD) {
// Start recording
startRecording();
currentMode = PLAY; // Switch back to play mode after recording
}

// Smooth rotation handling
int encoderPosition = readEncoder();
if (encoderPosition != lastEncoderPosition) {
if (encoderPosition > lastEncoderPosition) {
currentFileIndex++;
} else {
currentFileIndex--;
}
// Ensure currentFileIndex stays within bounds (1-999)
if (currentFileIndex < 1) {
currentFileIndex = 999;
} else if (currentFileIndex > 999) {
currentFileIndex = 1;
}
lastEncoderPosition = encoderPosition;
Serial.print("Selected file: ");
Serial.println(currentFileIndex);
}

if (buttonPressed) {
playSelectedFile(currentFileIndex);
buttonPressed = false;
}
}

void buttonInterrupt() {
buttonPressed = true;
}

int readEncoder() {
static int previousA = LOW;
int A = digitalRead(ROTARY_ENCODER_CLK);
int B = digitalRead(ROTARY_ENCODER_DT);
int result = (previousA << 1) | B | (A << 2);
previousA = A;
return result & 0x0F;
}

void playSelectedFile(int fileIndex) {
Serial.print("Playing file: ");
Serial.println(fileIndex);
player.play(fileIndex);
}

void switchModes() {
// Smooth rotation handling for switching modes
int encoderPosition = readEncoder();
if (encoderPosition != lastEncoderPosition) {
if (encoderPosition > lastEncoderPosition) {
currentMode = RECORD;
Serial.println("Recording mode selected.");
} else {
currentMode = PLAY;
Serial.println("Play mode selected.");
}
lastEncoderPosition = encoderPosition;
}
}

void startRecording() {
Serial.println("Starting recording...");
delay(3000); // 3 second delay before recording starts
Serial.println("Recording...");

// Create buffer to store recorded audio data
size_t buffer_size = 4096;
uint8_t *buffer = (uint8_t *)malloc(buffer_size);

// Read audio data from I2S interface
size_t bytes_read = 0;
while (!buttonPressed) {
bytes_read += i2s_read(I2S_NUM_0, buffer + bytes_read, buffer_size - bytes_read, portMAX_DELAY);
}

// Save recorded audio data to SD card
saveToFile(buffer, bytes_read);

// Free buffer memory
free(buffer);

Serial.println("Recording stopped.");
}

void saveToFile(uint8_t *data, size_t size) {
// Open file on SD card
File file = SD.open("recorded_audio.raw", FILE_WRITE);
if (!file) {
Serial.println("Failed to open file for writing");
return;
}

// Write audio data to file
file.write(data, size);
file.close();
}
`

[vertigoooooooo]

^^ forgot to mention this is just code for trying to write data into the chip. I was going to attack playback only after I had any success with this. Cheers guys

[pschatzmann]

The goal of my library was to implement things like this with a minimum number of lines of code: The shorter the code, the easier it is to reason about it and to find errors or to evaluate alternatives.

I suggest that you have a look at this example.

I think it will be pretty difficult to use the DFPlayerMini since this seems to be able to process mp3 files only, and mp3 encoding on the ESP32 is possible, but it is a pain to get it working and you would need probably an ESP32 version which has PSRAM.

Should you be interested to use this library: please read the Wiki!