ESP32 Forum

Code: Select all

#include <stdio.h>
#include "driver/i2s.h"
#include "esp_system.h"
#include "esp_err.h"
#include "esp_log.h"
#include "driver/sdmmc_host.h"
#include "driver/sdspi_host.h"
#include "driver/spi_common.h"
#include "esp_vfs_fat.h"
#include "sdmmc_cmd.h"

#define I2S_NUM         I2S_NUM_0
#define SAMPLE_RATE     48000
#define I2S_BCK_IO      16
#define I2S_LRCK_IO     17
#define I2S_DATA_IO     8
#define I2S_MCLK_IO     18

#define SD_MISO_PIN     39
#define SD_MOSI_PIN     38
#define SD_SCK_PIN      37
#define SD_CS_PIN       36

// Using HSPI_HOST instead of VSPI_HOST
#define HSPI_HOST SPI2_HOST

#pragma pack(push, 1)
typedef struct {
    char riff_tag[4];
    int32_t riff_length;
    char wave_tag[4];
    char fmt_tag[4];
    int32_t fmt_length;
    int16_t audio_format;
    int16_t num_channels;
    int32_t sample_rate;
    int32_t byte_rate;
    int16_t block_align;
    int16_t bits_per_sample;
    char data_tag[4];
    int32_t data_length;
} wav_header_t;
#pragma pack(pop)

static const char* TAG = "esp32-i2s-adc";

void setup_i2s() {
    ESP_LOGI(TAG, "Initializing I2S");

    i2s_config_t i2s_config = {
        .mode = I2S_MODE_MASTER | I2S_MODE_RX,
        .sample_rate = SAMPLE_RATE,
        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
        .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
        .communication_format = I2S_COMM_FORMAT_I2S,
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
        .dma_buf_count = 2,
        .dma_buf_len = 1024,
        .use_apll = true,
        .fixed_mclk = SAMPLE_RATE * 256,
        .tx_desc_auto_clear = true,
    };

    i2s_pin_config_t pin_config = {
        .bck_io_num = I2S_BCK_IO,
        .ws_io_num = I2S_LRCK_IO,
        .data_out_num = I2S_PIN_NO_CHANGE,
        .data_in_num = I2S_DATA_IO,
        .mck_io_num = I2S_MCLK_IO
    };

    ESP_ERROR_CHECK(i2s_driver_install(I2S_NUM, &i2s_config, 0, NULL));
    ESP_ERROR_CHECK(i2s_set_pin(I2S_NUM, &pin_config));
    ESP_ERROR_CHECK(i2s_set_clk(I2S_NUM, SAMPLE_RATE, I2S_BITS_PER_SAMPLE_16BIT, I2S_CHANNEL_STEREO));
}

void setup_sdcard() {
    ESP_LOGI(TAG, "Initializing SD card");

    spi_bus_config_t bus_cfg = {
        .miso_io_num = SD_MISO_PIN,
        .mosi_io_num = SD_MOSI_PIN,
        .sclk_io_num = SD_SCK_PIN,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4094,  // Increased SPI maximum transfer size
    };

    esp_err_t ret = spi_bus_initialize(HSPI_HOST, &bus_cfg, 0);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to initialize SPI bus. Error code: %d", ret);
        return;
    }

    // This initializes the slot without card detect (CD) and write protect (WP) signals.
    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
    slot_config.gpio_cs = SD_CS_PIN;
    slot_config.host_id = HSPI_HOST;  // Use HSPI_HOST instead of VSPI_HOST

    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
        .format_if_mount_failed = false,
        .max_files = 5,
        .allocation_unit_size = 16 * 1024
    };

    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
    sdmmc_card_t* card;
    ESP_ERROR_CHECK(esp_vfs_fat_sdspi_mount("/sdcard", &host, &slot_config, &mount_config, &card));
}

void write_wav_header(FILE* file, int sample_rate, int bits_per_sample, int num_channels) {
    wav_header_t wav_header = {
        .riff_tag = {'R', 'I', 'F', 'F'},
        .riff_length = 0,
        .wave_tag = {'W', 'A', 'V', 'E'},
        .fmt_tag = {'f', 'm', 't', ' '},
        .fmt_length = 16,
        .audio_format = 1,
        .num_channels = num_channels,
        .sample_rate = sample_rate,
        .byte_rate = sample_rate * num_channels * bits_per_sample / 8,
        .block_align = num_channels * bits_per_sample / 8,
        .bits_per_sample = bits_per_sample,
        .data_tag = {'d', 'a', 't', 'a'},
        .data_length = 0
    };

    fwrite(&wav_header, sizeof(wav_header_t), 1, file);
}

void update_wav_header(FILE* file) {
    int file_length = ftell(file);

    fseek(file, 4, SEEK_SET);
    int32_t riff_length = file_length - 8;
    fwrite(&riff_length, sizeof(int32_t), 1, file);

    fseek(file, 40, SEEK_SET);
    int32_t data_length = file_length - 44;
    fwrite(&data_length, sizeof(int32_t), 1, file);
}

void app_main() {
    setup_i2s();
    setup_sdcard();

    int file_index = 0; // This will be incremented for each new file
    int bytes_written = 0;
    const int bytes_per_sample = 2;  // Assuming 16-bit samples
    const int sample_rate = SAMPLE_RATE;
    const int num_channels = 2;  // Stereo
    const int bytes_per_second = sample_rate * bytes_per_sample * num_channels;
    const int total_duration = 15;  // 15 seconds per file
    const int total_bytes = total_duration * bytes_per_second;

    char filename[64];

    sprintf(filename, "/sdcard/output_%d.wav", file_index);

    FILE* file = fopen(filename, "wb");
    if (file == NULL) {
        ESP_LOGE(TAG, "Failed to open file for writing");
        return;
    }

    write_wav_header(file, SAMPLE_RATE, 16, num_channels);

    while (1) {
        uint8_t i2sData[1024];
        size_t bytesRead;
        ESP_ERROR_CHECK(i2s_read(I2S_NUM, i2sData, 1024, &bytesRead, portMAX_DELAY));

        fwrite(i2sData, sizeof(uint8_t), bytesRead, file);

        bytes_written += bytesRead;

        ESP_LOGI(TAG, "Bytes read: %d", bytesRead);

        // If we've written 15 seconds worth of data, close the current file and open a new one
        if (bytes_written >= total_bytes) {
            update_wav_header(file);
            fclose(file);

            // Reset bytes_written for the next file
            bytes_written = 0;

            // Increment file_index for a unique filename
            file_index++;

            sprintf(filename, "/sdcard/output_%d.wav", file_index);

            file = fopen(filename, "wb");
            if (file == NULL) {
                ESP_LOGE(TAG, "Failed to open file for writing");
                return;
            }

            write_wav_header(file, SAMPLE_RATE, 16, num_channels);
        }
    }
}