Scribd
Upload
28 views

ESP32RX

Uploaded by

aliww1935
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
28 views

ESP32RX

Uploaded by

aliww1935
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 4

// will play many audio file formats, mp3,aac,flac etc.

// See github page : https://github.com/schreibfaul1/ESP32-audioI2S

#include "Arduino.h"
#include "Audio.h"
#include "SD.h"
#include "FS.h"
#include <driver/i2s.h>
#include <stdint.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 RXp2 16
#define TXp2 17

#define SAMPLE_RATE 15000

size_t byteCounter = 0;
uint32_t fileSize;
const short bytesPerWrite = 4;
const int arrSize = 2;
int receivedSample;
uint8_t samplesArray[arrSize];

bool isRecording = true, isPlaying = false, alternator = false;


const char fileName[] = "/0006.wav";

unsigned long loopCounter = 0, preMillis = 0, currMillis = 0;


const unsigned long interval = 1000;

Audio audio1;
File audioFile;

void setup() {

pinMode(REC_BUTTON, INPUT_PULLUP);
pinMode(PLAY_BUTTON, INPUT_PULLUP);
pinMode(SD_CS, OUTPUT);
digitalWrite(SD_CS, HIGH);
SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI);

Serial.begin(9600);
Serial2.begin(115200, SERIAL_8N1, RXp2, TXp2);
delay(1000);
if (!SD.begin(SD_CS)) {
Serial.println("SD card initialization failed.");
return;
}
Serial.println("SD card initialized.");

audioFile = SD.open(fileName, FILE_WRITE);


if (!audioFile) {
Serial.println("Failed to open WAV file for writing.");
return;
}
Serial.println("WAV file opened successfuly.");

writeWavHeader(audioFile);

audio1.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);


audio1.setVolume(21);
audio1.setFileLoop(true);
}

void loop() {

if (isRecording) {

receivedSample = receiveData();
writeSample(audioFile, receivedSample);
Serial.print("Sample Value: ");
Serial.println(receivedSample);

if (digitalRead(REC_BUTTON) == LOW && isRecording) {

delay(50);
if (digitalRead(REC_BUTTON) == LOW) {

Serial.println("Recording stopped!");
isRecording = false;

headerSizeFiller();
audioFile.close();

fileSizePrinter();

Serial.println("Bytes written: " + String(byteCounter));


}
}

if (digitalRead(PLAY_BUTTON) == LOW && !isPlaying) {

delay(50);
if (digitalRead(PLAY_BUTTON == LOW)) {

isPlaying = true;
Serial.println("Button pressed. Waiting to play audio...");
playAudio();
}
}
}

int receiveData() {
int receivedData;

// Wait until at least sizeof(int) bytes are available to read


//while (Serial2.available() < sizeof(receivedData));

// Read the data byte by byte from the serial buffer


Serial2.readBytes((uint8_t*)&receivedData, sizeof(receivedData));

// Now you have receivedData as signed int


return receivedData;
}

void playAudio() {

audio1.connecttoFS(SD, "/0005.wav");

while(true) {

//currMillis = millis();
audio1.processLocalFile(30000000, 2);

if (digitalRead(PLAY_BUTTON) == LOW && isPlaying) {

delay(2000);
if (digitalRead(PLAY_BUTTON == LOW)) {

isPlaying = true;
Serial.println("Playing audio...");
playAudio();
}
}

/*if (currMillis - preMillis >= interval) {


// calculate frequency
float frequency = (float)loopCounter / (float)interval * 1000.0;

// print frequency
Serial.print("Frequency: ");
Serial.print(frequency);
Serial.println(" Hz");

// reset loop counter and update previousMillis


loopCounter = 0;
preMillis = currMillis;
}
loopCounter++;*/
//delayMicroseconds(63);
}
}

void writeSample(File &file, int sample) {


// Ensure sample is within the range of a 12-bit signed integer
uint8_t bytes[2];
bytes[0] = ((sample + 0x8000) >> 8);
bytes[1] = sample;

file.write(bytes, 2);
byteCounter += 2;
}

void fileSizePrinter() {

audioFile = SD.open(fileName, FILE_READ);


fileSize = audioFile.size();
Serial.println("File size: " + String(fileSize));
audioFile.close();
}

void headerSizeFiller() {

audioFile.seek(4);
audioFile.write((uint8_t*)&fileSize, 4); // File size placeholder
audioFile.seek(40);
audioFile.write((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";
file.write((const uint8_t*)riffHeader, 4); // RIFF header
file.write((uint8_t*)&fileSizeH, 4); // File size placeholder
const char waveHeader[] = "WAVE";
file.write((const uint8_t*)waveHeader, 4); // WAV format
const char fmtHeader[] = "fmt ";
file.write((const uint8_t*)fmtHeader, 4); // Format chunk
uint32_t fmtSize = 16;
file.write((uint8_t*)&fmtSize, 4); // Format chunk size
uint16_t audioFormat = 1; // PCM format
file.write((uint8_t*)&audioFormat, 2); // Audio format
uint16_t numChannels = 1; // Mono
file.write((uint8_t*)&numChannels, 2); // Number of channels
uint32_t sampleRate = SAMPLE_RATE; // Sample rate
file.write((uint8_t*)&sampleRate, 4); // Sample rate
uint32_t byteRate = sampleRate * numChannels * (16 / 8); // Byte rate
file.write((uint8_t*)&byteRate, 4); // Byte rate
uint16_t blockAlign = numChannels * (16 / 8); // Block align
file.write((uint8_t*)&blockAlign, 2); // Block align
uint16_t bitsPerSample = 16; // Bits per sample
file.write((uint8_t*)&bitsPerSample, 2); // Bits per sample
const char dataHeader[] = "data";
file.write((const uint8_t*)dataHeader, 4); // Data chunk
file.write((uint8_t*)&dataSize, 4); // Data size placeholder
}

You might also like