ESP32 + I2S - Immer nur Brummen zu hören

/*

 * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD

 *

 * SPDX-License-Identifier: Unlicense OR CC0-1.0

 */

#include <stdint.h>

#include <stdlib.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "driver/i2s_std.h"

#include "driver/gpio.h"

#include "esp_check.h"

#include "sdkconfig.h"

#include "i2s_example_pins.h"

#include <math.h>

/* Set 1 to allocate rx & tx channels in duplex mode on a same I2S controller, they will share the BCLK and WS signal

 * Set 0 to allocate rx & tx channels in simplex mode, these two channels will be totally separated,

 * Specifically, due to the hardware limitation, the simplex rx & tx channels can't be registered on the same controllers on ESP32 and ESP32-S2,

 * and ESP32-S2 has only one I2S controller, so it can't allocate two simplex channels */

#define EXAMPLE_I2S_DUPLEX_MODE         CONFIG_USE_DUPLEX

#define EXAMPLE_STD_BCLK_IO1        EXAMPLE_I2S_BCLK_IO1      // I2S bit clock io number

#define EXAMPLE_STD_WS_IO1          EXAMPLE_I2S_WS_IO1      // I2S word select io number

#define EXAMPLE_STD_DOUT_IO1        EXAMPLE_I2S_DOUT_IO1     // I2S data out io number

#define EXAMPLE_STD_DIN_IO1         EXAMPLE_I2S_DIN_IO1     // I2S data in io number

#if !EXAMPLE_I2S_DUPLEX_MODE

#define EXAMPLE_STD_BCLK_IO2        EXAMPLE_I2S_BCLK_IO2     // I2S bit clock io number

#define EXAMPLE_STD_WS_IO2          EXAMPLE_I2S_WS_IO2     // I2S word select io number

#define EXAMPLE_STD_DOUT_IO2        EXAMPLE_I2S_DOUT_IO2     // I2S data out io number

#define EXAMPLE_STD_DIN_IO2         EXAMPLE_I2S_DIN_IO2     // I2S data in io number

#endif

#define EXAMPLE_BUFF_SIZE               2048

#define SAMPLE_RATE 22050

static i2s_chan_handle_t                tx_chan;        // I2S tx channel handler

static i2s_chan_handle_t                rx_chan;        // I2S rx channel handler

static void i2s_example_read_task(void *args)

{

    uint8_t *r_buf = (uint8_t *)calloc(1, EXAMPLE_BUFF_SIZE);

    assert(r_buf); // Check if r_buf allocation success

    size_t r_bytes = 0;

    /* Enable the RX channel */

    ESP_ERROR_CHECK(i2s_channel_enable(rx_chan));

    /* ATTENTION: The print and delay in the read task only for monitoring the data by human,

     * Normally there shouldn't be any delays to ensure a short polling time,

     * Otherwise the dma buffer will overflow and lead to the data lost */

    while (1) {

        /* Read i2s data */

        if (i2s_channel_read(rx_chan, r_buf, EXAMPLE_BUFF_SIZE, &r_bytes, 1000) == ESP_OK) {

            printf("Read Task: i2s read %d bytes\n-----------------------------------\n", r_bytes);

            printf("[0] %x [1] %x [2] %x [3] %x\n[4] %x [5] %x [6] %x [7] %x\n\n",

                   r_buf[0], r_buf[1], r_buf[2], r_buf[3], r_buf[4], r_buf[5], r_buf[6], r_buf[7]);

        } else {

            printf("Read Task: i2s read failed\n");

        }

        vTaskDelay(pdMS_TO_TICKS(200));

    }

    free(r_buf);

    vTaskDelete(NULL);

}

static void i2s_example_write_task(void *args)

{

    uint8_t *w_buf = (uint8_t *)calloc(1, EXAMPLE_BUFF_SIZE);

    assert(w_buf); // Check if w_buf allocation success

    for (int i = 0; i < EXAMPLE_BUFF_SIZE / 2; i++) {

        float phase = (2.0f * M_PI * i) / (SAMPLE_RATE / 220);

        int16_t sample = (int16_t)(127 * sinf(phase));

        w_buf[i] = sample;  // Kein MSB nötig bei 8 Bit

        w_buf[2 * i + 1] = (sample >> 8) & 0xFF; // MSB

}

    size_t w_bytes = EXAMPLE_BUFF_SIZE;

    /* (Optional) Preload the data before enabling the TX channel, so that the valid data can be transmitted immediately */

    while (w_bytes == EXAMPLE_BUFF_SIZE) {

        /* Here we load the target buffer repeatedly, until all the DMA buffers are preloaded */

        ESP_ERROR_CHECK(i2s_channel_preload_data(tx_chan, w_buf, EXAMPLE_BUFF_SIZE, &w_bytes));

    }

    /* Enable the TX channel */

    ESP_ERROR_CHECK(i2s_channel_enable(tx_chan));

    while (1) {

        /* Write i2s data */

        if (i2s_channel_write(tx_chan, w_buf, EXAMPLE_BUFF_SIZE, &w_bytes, 1000) == ESP_OK) {

            printf("Write Task: i2s write %d bytes\n", w_bytes);

        } else {

            printf("Write Task: i2s write failed\n");

        }

        vTaskDelay(pdMS_TO_TICKS(200));

    }

    free(w_buf);

    vTaskDelete(NULL);

}

static void i2s_example_init_std_simplex(void)

{

    /* Setp 1: Determine the I2S channel configuration and allocate two channels one by one

     * The default configuration can be generated by the helper macro,

     * it only requires the I2S controller id and I2S role

     * The tx and rx channels here are registered on different I2S controller,

     * Except ESP32 and ESP32-S2, others allow to register two separate tx & rx channels on a same controller */

    i2s_chan_config_t tx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO, I2S_ROLE_MASTER);

    ESP_ERROR_CHECK(i2s_new_channel(&tx_chan_cfg, &tx_chan, NULL));

    i2s_chan_config_t rx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO, I2S_ROLE_MASTER);

    ESP_ERROR_CHECK(i2s_new_channel(&rx_chan_cfg, NULL, &rx_chan));

    /* Step 2: Setting the configurations of standard mode and initialize each channels one by one

     * The slot configuration and clock configuration can be generated by the macros

     * These two helper macros is defined in 'i2s_std.h' which can only be used in STD mode.

     * They can help to specify the slot and clock configurations for initialization or re-configuring */

i2s_std_config_t std_cfg = {

    .clk_cfg = {

        .sample_rate_hz = SAMPLE_RATE,

        .clk_src = I2S_CLK_SRC_DEFAULT,

        .mclk_multiple = I2S_MCLK_MULTIPLE_256

    },

   .slot_cfg = {

    .data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,

    .slot_bit_width = I2S_SLOT_BIT_WIDTH_16BIT,

    .slot_mode = I2S_SLOT_MODE_STEREO,

    .slot_mask = I2S_STD_SLOT_BOTH,

    .ws_width = I2S_DATA_BIT_WIDTH_16BIT,

    .ws_pol = false,

    .bit_shift = true,

    .msb_right = false

    },

    .gpio_cfg = {

        .mclk = I2S_GPIO_UNUSED,

        .bclk = GPIO_NUM_5,

        .ws   = GPIO_NUM_25,

        .dout = GPIO_NUM_26,

        .din  = I2S_GPIO_UNUSED,

        .invert_flags = {

            .mclk_inv = false,

            .bclk_inv = false,

            .ws_inv   = false

        }

    }

};

   ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_chan, &std_cfg));

    i2s_std_config_t rx_std_cfg = {

        .clk_cfg  = I2S_STD_CLK_DEFAULT_CONFIG(22050),

        .slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),

        .gpio_cfg = {

            .mclk = I2S_GPIO_UNUSED,    // some codecs may require mclk signal, this example doesn't need it

            .bclk = EXAMPLE_STD_BCLK_IO2,

            .ws   = EXAMPLE_STD_WS_IO2,

            .dout = EXAMPLE_STD_DOUT_IO2,

            .din  = EXAMPLE_STD_DIN_IO2,

            .invert_flags = {

                .mclk_inv = false,

                .bclk_inv = false,

                .ws_inv   = false,

            },

        },

    };

    /* Default is only receiving left slot in mono mode,

     * update to right here to show how to change the default configuration */

    rx_std_cfg.slot_cfg.slot_mask = I2S_STD_SLOT_RIGHT;

    ESP_ERROR_CHECK(i2s_channel_init_std_mode(rx_chan, &rx_std_cfg));

}

extern "C" void app_main(void)

{

#if EXAMPLE_I2S_DUPLEX_MODE

    i2s_example_init_std_duplex();

#else

    i2s_example_init_std_simplex();

#endif

    /* Step 3: Create writing and reading task, enable and start the channels */

    xTaskCreate(i2s_example_read_task, "i2s_example_read_task", 4096, NULL, 5, NULL);

    xTaskCreate(i2s_example_write_task, "i2s_example_write_task", 4096, NULL, 5,