bsp: Added support for IDF v4.4 into ESP32-S3-EYE

.build-test-rules.yml

@@ -1,4 +1,4 @@
 examples:
   disable:
-    - if: IDF_VERSION_MAJOR < 5 and CONFIG_NAME not in ["esp-box", "esp-box-lite"]
+    - if: IDF_VERSION_MAJOR < 5 and CONFIG_NAME not in ["esp-box", "esp-box-lite", "esp32_s3_eye"]
       reason: Example depends on BSP, which is supported only for IDF >= 5.0

esp32_s3_eye/CMakeLists.txt

@@ -1,7 +1,14 @@
+#IDF version is less than IDF5.0
+if("${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}" VERSION_LESS "5.0")
+    set(SRC_VER "esp32_s3_eye_idf4.c")
+else()
+    set(SRC_VER "esp32_s3_eye_idf5.c")
+endif()
+
 idf_component_register(
-    SRCS "esp32_s3_eye.c"
+    SRCS "esp32_s3_eye.c" ${SRC_VER}
     INCLUDE_DIRS "include"
     PRIV_INCLUDE_DIRS "priv_include"
-    REQUIRES driver
+    REQUIRES driver spiffs
     PRIV_REQUIRES fatfs esp_lcd
 )

esp32_s3_eye/Kconfig

@@ -25,6 +25,33 @@ menu "Board Support Package"
             default 400000 if BSP_I2C_FAST_MODE
             default 100000
     endmenu
+
+    menu "SPIFFS - Virtual File System"
+        config BSP_SPIFFS_FORMAT_ON_MOUNT_FAIL
+            bool "Format SPIFFS if mounting fails"
+            default n
+            help
+                Format SPIFFS if it fails to mount the filesystem.
+
+        config BSP_SPIFFS_MOUNT_POINT
+            string "SPIFFS mount point"
+            default "/spiffs"
+            help
+                Mount point of SPIFFS in the Virtual File System.
+
+        config BSP_SPIFFS_PARTITION_LABEL
+            string "Partition label of SPIFFS"
+            default "storage"
+            help
+                Partition label which stores SPIFFS.
+
+        config BSP_SPIFFS_MAX_FILES
+            int "Max files supported for SPIFFS VFS"
+            default 5
+            help
+                Supported max files for SPIFFS in the Virtual File System.
+    endmenu
+
     menu "uSD card - Virtual File System"
         config BSP_SD_FORMAT_ON_MOUNT_FAIL
             bool "Format uSD card if mounting fails"
@@ -61,4 +88,11 @@ menu "Board Support Package"
                 LEDC channel is used to generate PWM signal that controls display brightness.
                 Set LEDC index that should be used.
     endmenu
+
+    config BSP_I2S_NUM
+        int "I2S peripheral index"
+        default 1
+        range 0 1
+        help
+            ESP32S3 has two I2S peripherals, pick the one you want to use.
 endmenu

esp32_s3_eye/esp32_s3_eye.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -11,6 +11,8 @@
 #include "esp_lcd_panel_ops.h"
 #include "esp_log.h"
 #include "esp_check.h"
+#include "esp_vfs_fat.h"
+#include "esp_spiffs.h"
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
@@ -27,31 +29,46 @@
 static const char *TAG = "S3-EYE";
 
 sdmmc_card_t *bsp_sdcard = NULL;    // Global uSD card handler
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+static adc_oneshot_unit_handle_t bsp_adc_handle = NULL;
+#endif
 
-const button_config_t bsp_button_config[BSP_BUTTON_NUM] = {
+static const button_config_t bsp_button_config[BSP_BUTTON_NUM] = {
     {
         .type = BUTTON_TYPE_ADC,
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+        .adc_button_config.adc_handle = &bsp_adc_handle,
+#endif
         .adc_button_config.adc_channel = ADC_CHANNEL_0, // ADC1 channel 0 is GPIO1
         .adc_button_config.button_index = BSP_BUTTON_MENU,
         .adc_button_config.min = 2310, // middle is 2410mV
         .adc_button_config.max = 2510
     },
     {
         .type = BUTTON_TYPE_ADC,
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+        .adc_button_config.adc_handle = &bsp_adc_handle,
+#endif
         .adc_button_config.adc_channel = ADC_CHANNEL_0, // ADC1 channel 0 is GPIO1
         .adc_button_config.button_index = BSP_BUTTON_PLAY,
         .adc_button_config.min = 1880, // middle is 1980mV
         .adc_button_config.max = 2080
     },
     {
         .type = BUTTON_TYPE_ADC,
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+        .adc_button_config.adc_handle = &bsp_adc_handle,
+#endif
         .adc_button_config.adc_channel = ADC_CHANNEL_0, // ADC1 channel 0 is GPIO1
         .adc_button_config.button_index = BSP_BUTTON_DOWN,
         .adc_button_config.min = 720, // middle is 820mV
         .adc_button_config.max = 920
     },
     {
         .type = BUTTON_TYPE_ADC,
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+        .adc_button_config.adc_handle = &bsp_adc_handle,
+#endif
         .adc_button_config.adc_channel = ADC_CHANNEL_0, // ADC1 channel 0 is GPIO1
         .adc_button_config.button_index = BSP_BUTTON_UP,
         .adc_button_config.min = 280, // middle is 380mV
@@ -61,6 +78,13 @@ const button_config_t bsp_button_config[BSP_BUTTON_NUM] = {
 
 esp_err_t bsp_i2c_init(void)
 {
+    static bool i2c_initialized = false;
+
+    /* I2C was initialized before */
+    if (i2c_initialized) {
+        return ESP_OK;
+    }
+
     const i2c_config_t i2c_conf = {
         .mode = I2C_MODE_MASTER,
         .sda_io_num = BSP_I2C_SDA,
@@ -72,6 +96,8 @@ esp_err_t bsp_i2c_init(void)
     BSP_ERROR_CHECK_RETURN_ERR(i2c_param_config(BSP_I2C_NUM, &i2c_conf));
     BSP_ERROR_CHECK_RETURN_ERR(i2c_driver_install(BSP_I2C_NUM, i2c_conf.mode, 0, 0, 0));
 
+    i2c_initialized = true;
+
     return ESP_OK;
 }
 
@@ -81,6 +107,38 @@ esp_err_t bsp_i2c_deinit(void)
     return ESP_OK;
 }
 
+esp_err_t bsp_spiffs_mount(void)
+{
+    esp_vfs_spiffs_conf_t conf = {
+        .base_path = CONFIG_BSP_SPIFFS_MOUNT_POINT,
+        .partition_label = CONFIG_BSP_SPIFFS_PARTITION_LABEL,
+        .max_files = CONFIG_BSP_SPIFFS_MAX_FILES,
+#ifdef CONFIG_BSP_SPIFFS_FORMAT_ON_MOUNT_FAIL
+        .format_if_mount_failed = true,
+#else
+        .format_if_mount_failed = false,
+#endif
+    };
+
+    esp_err_t ret_val = esp_vfs_spiffs_register(&conf);
+
+    BSP_ERROR_CHECK_RETURN_ERR(ret_val);
+
+    size_t total = 0, used = 0;
+    ret_val = esp_spiffs_info(conf.partition_label, &total, &used);
+    if (ret_val != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to get SPIFFS partition information (%s)", esp_err_to_name(ret_val));
+    } else {
+        ESP_LOGI(TAG, "Partition size: total: %d, used: %d", total, used);
+    }
+
+    return ret_val;
+}
+
+esp_err_t bsp_spiffs_unmount(void)
+{
+    return esp_vfs_spiffs_unregister(CONFIG_BSP_SPIFFS_PARTITION_LABEL);
+}
 
 esp_err_t bsp_sdcard_mount(void)
 {
@@ -112,12 +170,16 @@ esp_err_t bsp_sdcard_mount(void)
         .flags = 0,
     };
 
-    return esp_vfs_fat_sdmmc_mount(BSP_MOUNT_POINT, &host, &slot_config, &mount_config, &bsp_sdcard);
+#if !CONFIG_FATFS_LONG_FILENAMES
+    ESP_LOGW(TAG, "Warning: Long filenames on SD card are disabled in menuconfig!");
+#endif
+
+    return esp_vfs_fat_sdmmc_mount(BSP_SD_MOUNT_POINT, &host, &slot_config, &mount_config, &bsp_sdcard);
 }
 
 esp_err_t bsp_sdcard_unmount(void)
 {
-    return esp_vfs_fat_sdcard_unmount(BSP_MOUNT_POINT, bsp_sdcard);
+    return esp_vfs_fat_sdcard_unmount(BSP_SD_MOUNT_POINT, bsp_sdcard);
 }
 
 #define LCD_CMD_BITS         (8)
@@ -275,16 +337,25 @@ static lv_disp_t *bsp_display_lcd_init(void)
 
 lv_disp_t *bsp_display_start(void)
 {
-    lv_disp_t *disp = NULL;
-    const lvgl_port_cfg_t lvgl_cfg = {
-        .task_priority = CONFIG_BSP_DISPLAY_LVGL_TASK_PRIORITY,
-        .task_stack = 4096,
-        .task_affinity = 1,
-        .timer_period_ms = LVGL_TICK_PERIOD_MS,
-        .task_max_sleep_ms = 1,
+    bsp_display_cfg_t cfg = {
+        .lvgl_port_cfg = {
+            .task_priority = CONFIG_BSP_DISPLAY_LVGL_TASK_PRIORITY,
+            .task_stack = 4096,
+            .task_affinity = 1,
+            .timer_period_ms = LVGL_TICK_PERIOD_MS,
+            .task_max_sleep_ms = 1,
+        }
     };
-    BSP_ERROR_CHECK_RETURN_NULL(lvgl_port_init(&lvgl_cfg));
+    return bsp_display_start_with_config(&cfg);
+}
+
+lv_disp_t *bsp_display_start_with_config(const bsp_display_cfg_t *cfg)
+{
+    lv_disp_t *disp;
+    assert(cfg != NULL);
+    BSP_ERROR_CHECK_RETURN_NULL(lvgl_port_init(&cfg->lvgl_port_cfg));
     BSP_NULL_CHECK(disp = bsp_display_lcd_init(), NULL);
+
     return disp;
 }
 
@@ -327,23 +398,51 @@ esp_err_t bsp_led_set(const bsp_led_t led_io, const bool on)
     return ESP_OK;
 }
 
-esp_err_t bsp_audio_init(const i2s_std_config_t *i2s_config, i2s_chan_handle_t *tx_channel, i2s_chan_handle_t *rx_channel)
+esp_codec_dev_handle_t bsp_audio_codec_microphone_init(void)
 {
-    /* Setup I2S peripheral */
-    const i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO, I2S_ROLE_MASTER);
-    BSP_ERROR_CHECK_RETURN_ERR(i2s_new_channel(&chan_cfg, NULL, rx_channel));
-    if (tx_channel) {
-        *tx_channel = NULL; // TX is not used in ESP32-S3-EYE board
+    const audio_codec_data_if_t *i2s_data_if = bsp_audio_get_codec_itf();
+    if (i2s_data_if == NULL) {
+        /* Initilize I2C */
+        BSP_ERROR_CHECK_RETURN_NULL(bsp_i2c_init());
+        /* Configure I2S peripheral and Power Amplifier */
+        BSP_ERROR_CHECK_RETURN_NULL(bsp_audio_init(NULL));
+        i2s_data_if = bsp_audio_get_codec_itf();
     }
+    assert(i2s_data_if);
 
-    /* Setup I2S channel */
-    const i2s_std_config_t std_cfg_default = BSP_I2S_SIMPLEX_MONO_CFG(); // Default config
-    const i2s_std_config_t *p_i2s_cfg = i2s_config ? i2s_config : &std_cfg_default;
+    esp_codec_dev_cfg_t codec_dev_cfg = {
+        .dev_type = ESP_CODEC_DEV_TYPE_IN,
+        .codec_if = NULL,
+        .data_if = i2s_data_if,
+    };
+    return esp_codec_dev_new(&codec_dev_cfg);
+}
 
-    if (rx_channel != NULL) {
-        BSP_ERROR_CHECK_RETURN_ERR(i2s_channel_init_std_mode(*rx_channel, p_i2s_cfg));
-        BSP_ERROR_CHECK_RETURN_ERR(i2s_channel_enable(*rx_channel));
+esp_err_t bsp_iot_button_create(button_handle_t btn_array[], int *btn_cnt, int btn_array_size)
+{
+    esp_err_t ret = ESP_OK;
+    if ((btn_array_size < BSP_BUTTON_NUM) ||
+            (btn_array == NULL)) {
+        return ESP_ERR_INVALID_ARG;
     }
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+    /* Initialize ADC and get ADC handle */
+    BSP_ERROR_CHECK_RETURN_NULL(bsp_adc_initialize());
+    bsp_adc_handle = bsp_adc_get_handle();
+#endif
 
-    return ESP_OK;
+    if (btn_cnt) {
+        *btn_cnt = 0;
+    }
+    for (int i = 0; i < BSP_BUTTON_NUM; i++) {
+        btn_array[i] = iot_button_create(&bsp_button_config[i]);
+        if (btn_array[i] == NULL) {
+            ret = ESP_FAIL;
+            break;
+        }
+        if (btn_cnt) {
+            (*btn_cnt)++;
+        }
+    }
+    return ret;
 }

esp32_s3_eye/esp32_s3_eye_idf4.c

@@ -0,0 +1,83 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "esp_err.h"
+#include "bsp/esp32_s3_eye.h"
+#include "bsp_err_check.h"
+#include "esp_codec_dev_defaults.h"
+
+static const char *TAG = "ESP-BOX";
+
+/* Sample rate of MSM261S4030H0 */
+#define BSP_MIC_SAMPLE_RATE (48000u)
+
+/* This configuration is used by default in bsp_audio_init() */
+#define BSP_I2S_SIMPLEX_MONO_CFG(_sample_rate)                      \
+    {                                                                 \
+        .mode = I2S_MODE_MASTER | I2S_MODE_TX | I2S_MODE_RX,          \
+        .sample_rate = _sample_rate,                                  \
+        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,                 \
+        .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,                  \
+        .communication_format = I2S_COMM_FORMAT_STAND_I2S,            \
+        .dma_buf_count = 3,                                           \
+        .dma_buf_len = 1024,                                          \
+        .use_apll = true,                                             \
+        .tx_desc_auto_clear = true,                                   \
+        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_IRAM \
+    }
+
+static const audio_codec_data_if_t *i2s_data_if = NULL;  /* Codec data interface */
+
+esp_err_t bsp_audio_init(const i2s_config_t *i2s_config)
+{
+    esp_err_t ret = ESP_FAIL;
+
+    if (i2s_data_if != NULL) {
+        /* Audio was initialized before */
+        return ESP_OK;
+    }
+
+    /* Setup I2S peripheral */
+    const i2s_pin_config_t i2s_pin_config = {
+        .mck_io_num = GPIO_NUM_NC,
+        .bck_io_num = BSP_I2S_SCLK,
+        .ws_io_num = BSP_I2S_LCLK,
+        .data_out_num = GPIO_NUM_NC,
+        .data_in_num = BSP_I2S_DIN
+    };
+
+    /* Setup I2S channels */
+    const i2s_config_t std_cfg_default = BSP_I2S_SIMPLEX_MONO_CFG(BSP_MIC_SAMPLE_RATE);
+    const i2s_config_t *p_i2s_cfg = &std_cfg_default;
+    if (i2s_config != NULL) {
+        p_i2s_cfg = i2s_config;
+    }
+
+    ESP_ERROR_CHECK(i2s_driver_install(CONFIG_BSP_I2S_NUM, p_i2s_cfg, 0, NULL));
+    ESP_GOTO_ON_ERROR(i2s_set_pin(CONFIG_BSP_I2S_NUM, &i2s_pin_config), err, TAG, "I2S set pin failed");
+
+    audio_codec_i2s_cfg_t i2s_cfg = {
+        .port = CONFIG_BSP_I2S_NUM,
+    };
+    i2s_data_if = audio_codec_new_i2s_data(&i2s_cfg);
+    BSP_NULL_CHECK_GOTO(i2s_data_if, err);
+
+    return ESP_OK;
+
+err:
+    i2s_driver_uninstall(CONFIG_BSP_I2S_NUM);
+    return ret;
+}
+
+const audio_codec_data_if_t *bsp_audio_get_codec_itf(void)
+{
+    return i2s_data_if;
+}
+
+esp_err_t bsp_adc_initialize(void)
+{
+    return ESP_OK;
+}