ESP32 Forum

Code: Select all

#define I2S_PORT (i2s_port_t)(0) // set main I2S port to I2S_NUM_0

// i2s config
const i2s_config_t i2s_config = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX), // receive
    .sample_rate = 44100,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT, // also tried 32 bit before
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // use right channel
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // interrupt level 1
    .dma_buf_count = 64,                      // number of buffers
    .dma_buf_len = 512
};

// pin config
const i2s_pin_config_t pin_config = {
    .bck_io_num = 33,            // serial clock, sck
    .ws_io_num = 32,              // word select, ws
    .data_out_num = I2S_PIN_NO_CHANGE, // only used for speakers
    .data_in_num = 34            // serial data, sd
};

Serial.println("-----Mic Controller-----");

// config i2s driver and pins
// fct must be called before any read/write
esp_err_t err = i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
if (err != ESP_OK)
{
    Serial.printf("Failed installing the driver: %d\n", err);
}

err = i2s_set_pin(I2S_PORT, &pin_config);
if (err != ESP_OK)
{
    Serial.printf("Failed setting pin: %d\n", err);
}

Serial.println("I2S driver installed! :-)");

Serial.println("------------------------");

Code: Select all

// 44,1KHz (SAMPLE_RATE) * Byte per sample * time in seconds = total size in bytes
const size_t recordSize = (44100 * I2S_BITS_PER_SAMPLE_16BIT/ 8) * recordTime; //recordTime = 2s

// size in bytes
size_t totalReadSize = 0;

// 16 bits per sample set in config * 1024 samples per buffers = total bits per buffer
const uint16_t totalBitsPerBuffer = 44100 * I2S_BITS_PER_SAMPLE_16BIT;
char *samples = (char *)calloc(totalBitsPerBuffer, sizeof(char));

// number of bytes read
size_t bytesRead;

Serial.println("Start recording...");
// read until wanted size is reached
while (totalReadSize < recordSize)
{
    // read to buffer
    esp_err_t err = i2s_read(I2S_PORT, (void *)samples, totalBitsPerBuffer, &bytesRead, portMAX_DELAY);

    // check if error occurd, if so stop recording
    if (err != ESP_OK)
    {
        Serial.println("Error while recording!");
        break;
    }

    printf("=======\n");
    for (int i = 0; i < bytesRead; i++)
    {
        printf("%02x ", (uint8_t)samples[i]);
        if ((i + 1) % 8 == 0)
        {
            printf("\n");
        }
    }
    printf("=======\n");

    // add read size to total read size
    totalReadSize += bytesRead;
}

HttpController httpController("http://192.168.2.100:8080");
httpController.postRequest("/esp/audio", "application/octet-stream", "", (uint8_t *)samples, totalReadSize);

Code: Select all

app.post('/esp/audio', (req, res) => {
    console.log(`Got ${req.body.length} I2S bytes`);
    fs.writeFile('audio.raw', req.body, () => {
        res.sendStatus(200);
    });
});

Code: Select all

#define SAMPLE_RATE (16000)
const i2s_bits_per_sample_t BITS_PER_SAMPLE = I2S_BITS_PER_SAMPLE_16BIT;

[...]


// record time in seconds
uint8_t *MicController::record(uint8_t recordTime)
{
    // 16KHz * Byte per sample * time in seconds = total size in bytes
    const size_t recordSize = (SAMPLE_RATE * BITS_PER_SAMPLE / 8) * recordTime;
    const size_t recordSize1s = (SAMPLE_RATE * BITS_PER_SAMPLE / 8) * 1;
    static int16_t i2sBuff[recordSize1s];

    // size in bytes
    size_t totalReadSize = 0;

    // 32 bits per sample set in config * 1024 samples per buffers = total bits per buffer
    char *samples = (char *)calloc(totalBitsPerBuffer, sizeof(char));

    // number of bytes read
    size_t bytesRead;

    Serial.println("Start recording...");
    // read until wanted size is reached
    while (totalReadSize < recordSize1s)
    {
        // read to buffer
        // esp_err_t err = i2s_read(I2S_PORT, (void *)samples, totalBitsPerBuffer, &bytesRead, portMAX_DELAY);
        
        // using recordSize1s and i2sBuff makes the reading from i2s work
        esp_err_t err = i2s_read(I2S_PORT, (char *)i2sBuff, recordSize1s, &bytesRead, (100 / portTICK_RATE_MS));

        // check if error occurd, if so stop recording
        if (err != ESP_OK)
        {
            Serial.println("Error while recording!");
            break;
        }

        // add read size to total read size
        totalReadSize += bytesRead;
    }

    // convert bytes to mb
    double_t totalReadSizeMB = (double_t)totalReadSize / 1e+6;

    Serial.printf("Total read size: %fMb\n", totalReadSizeMB);

    // todo send data in main.cpp
    HttpController httpController("http://192.168.2.100:8080");
    httpController.postRequest("/esp/audio", "application/octet-stream", "", (uint8_t *)i2sBuff, totalReadSize);

    return (uint8_t *)i2sBuff;
}

Code: Select all

const size_t recordSize2s = (SAMPLE_RATE * BITS_PER_SAMPLE / 8) * 2;

Code: Select all

const size_t recordSize2s = (SAMPLE_RATE * (BITS_PER_SAMPLE / 8)) * 2;

Code: Select all

static int16_t i2sBuff[recordSize2s];

Code: Select all

int16_t *i2sBuff = (int16_t *)calloc(recordSize2s, sizeof(char));

Code: Select all

#define SAMPLE_RATE (44100)
#define SAMPLES_PER_BUFFER (1024)                           // 256 samples per buffer
#define BITS_PER_SAMPLE (I2S_BITS_PER_SAMPLE_16BIT)        // num of bits per sample
#define SAMPLE_SIZE (BITS_PER_SAMPLE * SAMPLES_PER_BUFFER) // amount of bits per buffer
#define BYTES_PER_SAMPLE (BITS_PER_SAMPLE / 8)             // amount of bytes per sample
#define BYTE_RATE (SAMPLE_RATE * BYTES_PER_SAMPLE)         // amount of bytes per second

static int16_t i2s_buff[SAMPLE_SIZE];

// i2s config
const i2s_config_t i2s_config = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX), // receive
    .sample_rate = SAMPLE_RATE,
    .bits_per_sample = BITS_PER_SAMPLE,
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // use left channel
    .communication_format = I2S_COMM_FORMAT_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // interrupt level 1
    .dma_buf_count = 64,                      // number of buffers
    .dma_buf_len = SAMPLES_PER_BUFFER,        // number of sample per buffer
    .use_apll = 1                             // enable this to get accurate clock
};

[...]

// record for 2 seconds
const int32_t flashRecordSize = BYTE_RATE * 2;

// size in bytes
int totalReadSize = 0;

// number of bytes read
size_t bytesRead;

// start recording
while (totalReadSize < flashRecordSize)
{
    // read to buffer
    esp_err_t err = i2s_read(I2S_PORT, (char *)i2s_buff, SAMPLE_SIZE, &bytesRead, portMAX_DELAY);

    // check if error occurd, if so stop recording
    if (err != ESP_OK)
    {
        Serial.println("Error while recording!");
        break;
    }

    // add read size to total read size
    totalReadSize += bytesRead;
}