Alignement of (1) ESP Zero Code Matter examples and (2) ESP-Matter repository examples => Repo Light example not configured for light PMW driver (CON-1590)

[besbar]

Hi !

After few years working on Bluetooth Mesh and esp32, I am getting interested in Matter.

My first move was to burn a ESP32 feather with the light example (PWM driver) from Esp Zero Code. I then commissionned this device with Alexa and could control the RGB red led connected on PIN13 (power on/off and brightness from 0% to 100%).

Then I installed the ESP-Matter repository and setup my VS code (with ESP IDF extension, and esp-idf 5.2.3 installed, as it is recommanded) to access to the light example code and starting my education on Matter.
Second move, I burn the light example from the repository (with 1 GPIO led on pin13 configured) on a another esp32 feather., commission in Alexa. But I was unable to control the led.
Looking at the logs/code, I understand that the LEDC mode enabling controlling the led with PMW driver is not defined.

==> From menuconfig LED options, LED_LEDC_MODE (i.e. PMW driver) in function led_indicator_create() below is never attainable.

led_indicator_handle_t led_indicator_create(const led_indicator_config_t *config)
{
    esp_err_t ret = ESP_OK;
    bool if_blink_default_list = false;
    ESP_LOGI(TAG, "LED Indicator Version: %d.%d.%d", LED_INDICATOR_VER_MAJOR, LED_INDICATOR_VER_MINOR, LED_INDICATOR_VER_PATCH);
    LED_INDICATOR_CHECK(config != NULL, "invalid config pointer", return NULL);
    _led_indicator_com_config_t com_cfg = {0};
    _led_indicator_t *p_led_indicator = NULL;
    switch (config->mode) {
    case LED_GPIO_MODE: {
        void *hardware_data = NULL;
        const led_indicator_gpio_config_t *cfg = config->led_indicator_gpio_config;
        ret = led_indicator_gpio_init((void *)cfg, &hardware_data);
        LED_INDICATOR_CHECK(ESP_OK == ret, "GPIO mode init failed", return NULL);

        com_cfg.hardware_data = hardware_data;
        com_cfg.hal_indicator_set_on_off = led_indicator_gpio_set_on_off;
        com_cfg.hal_indicator_deinit = led_indicator_gpio_deinit;
        com_cfg.hal_indicator_set_brightness =  NULL;
        com_cfg.duty_resolution = LED_DUTY_1_BIT;
        break;
    }
    **case LED_LEDC_MODE: {
        const led_indicator_ledc_config_t *cfg = config->led_indicator_ledc_config;
        ret = led_indicator_ledc_init((void *)cfg);
        LED_INDICATOR_CHECK(ESP_OK == ret, "LEDC mode init failed", return NULL);
        com_cfg.hardware_data = (void *)cfg->channel;
        com_cfg.hal_indicator_set_on_off = led_indicator_ledc_set_on_off;
        com_cfg.hal_indicator_deinit = led_indicator_ledc_deinit;
        com_cfg.hal_indicator_set_brightness = led_indicator_ledc_set_brightness;
        com_cfg.duty_resolution = LED_DUTY_8_BIT;
        break;
    }**
    case LED_RGB_MODE: {
        void *hardware_data = NULL;
        const led_indicator_rgb_config_t *cfg = config->led_indicator_rgb_config;
        ret = led_indicator_rgb_init((void *)cfg, &hardware_data);
        LED_INDICATOR_CHECK(ESP_OK == ret, "LEDC mode init failed", return NULL);
        com_cfg.hardware_data = hardware_data;
        com_cfg.hal_indicator_set_on_off = led_indicator_rgb_set_on_off;
        com_cfg.hal_indicator_deinit = led_indicator_rgb_deinit;
        com_cfg.hal_indicator_set_brightness = led_indicator_rgb_set_brightness;
        com_cfg.hal_indicator_set_rgb = led_indicator_rgb_set_rgb;
        com_cfg.hal_indicator_set_hsv = led_indicator_rgb_set_hsv;
        com_cfg.duty_resolution = LED_DUTY_8_BIT;
        break;
    }
    case LED_STRIPS_MODE: {
        const led_indicator_strips_config_t *cfg = config->led_indicator_strips_config;
        void *hardware_data = NULL;
        ret = led_indicator_strips_init((void *)cfg, &hardware_data);
        LED_INDICATOR_CHECK(ESP_OK == ret, "LED rgb init failed", return NULL);
        com_cfg.hardware_data = hardware_data;
        com_cfg.hal_indicator_set_on_off = led_indicator_strips_set_on_off;
        com_cfg.hal_indicator_deinit = led_indicator_strips_deinit;
        com_cfg.hal_indicator_set_brightness = led_indicator_strips_set_brightness;
        com_cfg.hal_indicator_set_rgb = led_indicator_strips_set_rgb;
        com_cfg.hal_indicator_set_hsv = led_indicator_strips_set_hsv;
        com_cfg.duty_resolution = LED_DUTY_8_BIT;
        break;
    }
    case LED_CUSTOM_MODE: {
        const led_indicator_custom_config_t *cfg = config->led_indicator_custom_config;
        LED_INDICATOR_CHECK_WARNING(cfg->hal_indicator_init != NULL, "LED indicator does not have hal_indicator_init ", goto without_init);
        ret = cfg->hal_indicator_init(cfg->hardware_data);
        LED_INDICATOR_CHECK(ret == ESP_OK, "LED indicator init failed", return NULL);
without_init:
        com_cfg.hardware_data = cfg->hardware_data;
        com_cfg.hal_indicator_set_on_off = cfg->hal_indicator_set_on_off;
        com_cfg.hal_indicator_deinit = cfg->hal_indicator_deinit;
        com_cfg.hal_indicator_set_brightness = cfg->hal_indicator_set_brightness;
        com_cfg.hal_indicator_set_rgb = cfg->hal_indicator_set_rgb;
        com_cfg.hal_indicator_set_hsv = cfg->hal_indicator_set_hsv;
        com_cfg.duty_resolution = cfg->duty_resolution;
        break;
    }
    default:
        ESP_LOGE(TAG, "Unsupported indicator mode");
        goto unsupported_mode;
        break;
    }

    if (config->blink_lists == NULL) {
        ESP_LOGI(TAG, "blink_lists is null, use default blink list");
        com_cfg.blink_lists = default_led_indicator_blink_lists;
        com_cfg.blink_list_num = DEFAULT_BLINK_LIST_NUM;
        if_blink_default_list = true;
    } else {
        com_cfg.blink_lists = config->blink_lists;
        com_cfg.blink_list_num = config->blink_list_num;
    }

    p_led_indicator = _led_indicator_create_com(&com_cfg);

unsupported_mode:
    LED_INDICATOR_CHECK(NULL != p_led_indicator, "LED indicator create failed", return NULL);
    p_led_indicator->mode = config->mode;
    _led_indicator_add_node(p_led_indicator);
    ESP_LOGI(TAG, "Indicator create successfully. type:%s, hardware_data:%p, blink_lists:%s", led_indicator_mode_str[p_led_indicator->mode], p_led_indicator->hardware_data, if_blink_default_list ? "default" : "custom");
    return (led_indicator_handle_t)p_led_indicator;
}

There is indeed no led_indicator_config_t *config with config.mode = LED_LEDC_MODE available in esp_bsp_devkit.c.

static const led_indicator_config_t bsp_leds_config[BSP_LED_NUM] = {
#if CONFIG_BSP_LED_TYPE_RGB
    {
        .mode = LED_STRIPS_MODE,
        .led_indicator_strips_config = &bsp_leds_rgb_config,
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },
#elif CONFIG_BSP_LED_TYPE_RGB_CLASSIC
    {
        .mode = LED_RGB_MODE,
        .led_indicator_rgb_config = &bsp_leds_rgb_config,
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },

#elif CONFIG_BSP_LED_TYPE_GPIO

#if CONFIG_BSP_LEDS_NUM > 0
    {
        .mode = LED_GPIO_MODE,
        .led_indicator_gpio_config = &bsp_leds_gpio_config[0],
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },
#endif  // CONFIG_BSP_LEDS_NUM > 0
#if CONFIG_BSP_LEDS_NUM > 1
    {
        .mode = LED_GPIO_MODE,
        .led_indicator_gpio_config = &bsp_leds_gpio_config[1],
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },
#endif  // CONFIG_BSP_LEDS_NUM > 1
#if CONFIG_BSP_LEDS_NUM > 2
    {
        .mode = LED_GPIO_MODE,
        .led_indicator_gpio_config = &bsp_leds_gpio_config[2],
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },
#endif  // CONFIG_BSP_LEDS_NUM > 2
#if CONFIG_BSP_LEDS_NUM > 3
    {
        .mode = LED_GPIO_MODE,
        .led_indicator_gpio_config = &bsp_leds_gpio_config[3],
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },
#endif  // CONFIG_BSP_LEDS_NUM > 3
#if CONFIG_BSP_LEDS_NUM > 4
    {
        .mode = LED_GPIO_MODE,
        .led_indicator_gpio_config = &bsp_leds_gpio_config[4],
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },
#endif  // CONFIG_BSP_LEDS_NUM > 4
#endif // CONFIG_BSP_LED_TYPE_RGB/CONFIG_BSP_LED_TYPE_GPIO
};

So by adding some code below, I now can control the led, exactly as with the light example from esp zero code.
So my point of view is that it would be better if examples between repo and zero code platform could be better aligned.

#elif CONFIG_BSP_LED_TYPE_LEDC
    {
        .mode = LED_LEDC_MODE,
        .led_indicator_ledc_config = &bsp_leds_ledc_config,
        .blink_lists = bsp_led_blink_defaults_lists,
        .blink_list_num = BSP_LED_MAX,
    },

with (hard coded) definition of bsp_leds_ledc_config
#if CONFIG_BSP_LED_TYPE_LEDC
static led_indicator_ledc_config_t bsp_leds_ledc_config = {
    .channel = LEDC_CHANNEL_0,  // Exemple de canal LEDC
    .gpio_num = 13,  // Numéro GPIO associé à la LED
    .timer_num = LEDC_TIMER_0,  // Timer LEDC
    .is_active_level_high = true,  // Niveau actif haut
};
#endif // CONFIG_BSP_LED_TYPE_LEDC

and just adding this to KCONFIG
choice  
            prompt "LED type"
            default BSP_LED_TYPE_GPIO
            help
                Select a LED type: GPIO or LEDC
            config BSP_LED_TYPE_GPIO
                bool "GPIO LED"
            config BSP_LED_TYPE_RGB_CLASSIC
                bool "Classic RGB LED"
            config BSP_LED_TYPE_LEDC
                bool "LEDC LED"
            config BSP_LED_TYPE_RGB
                bool "Addressable RGB LED"
        endchoice

Thanks in advance for your remarks