matter usage of val on ESP32C6

[ravencarcass]

Hello creator and engineers,
I want to test some things with Matter. I made a custom program using the example of Matter. But I have problems with the data "esp_matter_attr_val_t *val". I thought that the OnOff value passes a True or a False and I also thought that the LevelControl passes a value between 0 and 100. You can see this in the code as well.

result:
After connecting the app to the microcontroller, I can see that it receives data from my phone, but no output is changed. I think I mishandled the value *fall, but I'm not sure how to fix it.

main code:

/*
   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

#include <esp_err.h>
#include <esp_log.h>
#include <nvs_flash.h>

#include <esp_matter.h>
#include <esp_matter_console.h>
#include <esp_matter_ota.h>

#include <common_macros.h>
#include <app_priv.h>
#include <app_reset.h>
#if CHIP_DEVICE_CONFIG_ENABLE_THREAD
#include <platform/ESP32/OpenthreadLauncher.h>
#endif

#include <app/server/CommissioningWindowManager.h>
#include <app/server/Server.h>

#ifdef CONFIG_ENABLE_SET_CERT_DECLARATION_API
#include <esp_matter_providers.h>
#include <lib/support/Span.h>
#ifdef CONFIG_SEC_CERT_DAC_PROVIDER
#include <platform/ESP32/ESP32SecureCertDACProvider.h>
#elif defined(CONFIG_FACTORY_PARTITION_DAC_PROVIDER)
#include <platform/ESP32/ESP32FactoryDataProvider.h>
#endif
using namespace chip::DeviceLayer;
#endif

static const char *TAG = "app_main";
uint16_t light_endpoint_id = 0;
uint16_t light_endpoint_id_1 = 0;
uint16_t light_endpoint_id_2 = 0;
uint16_t light_endpoint_id_3 = 0;
uint16_t light_endpoint_id_4 = 0;
uint16_t light_endpoint_id_5 = 0;
uint16_t light_endpoint_id_6 = 0;
uint16_t light_endpoint_id_7 = 0;
uint16_t light_endpoint_id_8 = 0;
uint16_t light_endpoint_id_9 = 0;
uint16_t light_endpoint_id_10 = 0;
uint16_t light_endpoint_id_11 = 0;



using namespace esp_matter;
using namespace esp_matter::attribute;
using namespace esp_matter::endpoint;
using namespace chip::app::Clusters;

constexpr auto k_timeout_seconds = 300;

#ifdef CONFIG_ENABLE_SET_CERT_DECLARATION_API
extern const uint8_t cd_start[] asm("_binary_certification_declaration_der_start");
extern const uint8_t cd_end[] asm("_binary_certification_declaration_der_end");

const chip::ByteSpan cdSpan(cd_start, static_cast<size_t>(cd_end - cd_start));
#endif // CONFIG_ENABLE_SET_CERT_DECLARATION_API

#if CONFIG_ENABLE_ENCRYPTED_OTA
extern const char decryption_key_start[] asm("_binary_esp_image_encryption_key_pem_start");
extern const char decryption_key_end[] asm("_binary_esp_image_encryption_key_pem_end");

static const char *s_decryption_key = decryption_key_start;
static const uint16_t s_decryption_key_len = decryption_key_end - decryption_key_start;
#endif // CONFIG_ENABLE_ENCRYPTED_OTA

static void app_event_cb(const ChipDeviceEvent *event, intptr_t arg)
{
    switch (event->Type) {
    case chip::DeviceLayer::DeviceEventType::kInterfaceIpAddressChanged:
        ESP_LOGI(TAG, "Interface IP Address changed");
        break;

    case chip::DeviceLayer::DeviceEventType::kCommissioningComplete:
        ESP_LOGI(TAG, "Commissioning complete");
        break;

    case chip::DeviceLayer::DeviceEventType::kFailSafeTimerExpired:
        ESP_LOGI(TAG, "Commissioning failed, fail safe timer expired");
        break;

    case chip::DeviceLayer::DeviceEventType::kCommissioningSessionStarted:
        ESP_LOGI(TAG, "Commissioning session started");
        break;

    case chip::DeviceLayer::DeviceEventType::kCommissioningSessionStopped:
        ESP_LOGI(TAG, "Commissioning session stopped");
        break;

    case chip::DeviceLayer::DeviceEventType::kCommissioningWindowOpened:
        ESP_LOGI(TAG, "Commissioning window opened");
        break;

    case chip::DeviceLayer::DeviceEventType::kCommissioningWindowClosed:
        ESP_LOGI(TAG, "Commissioning window closed");
        break;

    case chip::DeviceLayer::DeviceEventType::kFabricRemoved:
        {
            ESP_LOGI(TAG, "Fabric removed successfully");
            if (chip::Server::GetInstance().GetFabricTable().FabricCount() == 0)
            {
                chip::CommissioningWindowManager & commissionMgr = chip::Server::GetInstance().GetCommissioningWindowManager();
                constexpr auto kTimeoutSeconds = chip::System::Clock::Seconds16(k_timeout_seconds);
                if (!commissionMgr.IsCommissioningWindowOpen())
                {
                    /* After removing last fabric, this example does not remove the Wi-Fi credentials
                     * and still has IP connectivity so, only advertising on DNS-SD.
                     */
                    CHIP_ERROR err = commissionMgr.OpenBasicCommissioningWindow(kTimeoutSeconds,
                                                    chip::CommissioningWindowAdvertisement::kDnssdOnly);
                    if (err != CHIP_NO_ERROR)
                    {
                        ESP_LOGE(TAG, "Failed to open commissioning window, err:%" CHIP_ERROR_FORMAT, err.Format());
                    }
                }
            }
        break;
        }

    case chip::DeviceLayer::DeviceEventType::kFabricWillBeRemoved:
        ESP_LOGI(TAG, "Fabric will be removed");
        break;

    case chip::DeviceLayer::DeviceEventType::kFabricUpdated:
        ESP_LOGI(TAG, "Fabric is updated");
        break;

    case chip::DeviceLayer::DeviceEventType::kFabricCommitted:
        ESP_LOGI(TAG, "Fabric is committed");
        break;

    case chip::DeviceLayer::DeviceEventType::kBLEDeinitialized:
        ESP_LOGI(TAG, "BLE deinitialized and memory reclaimed");
        break;

    default:
        break;
    }
}

// This callback is invoked when clients interact with the Identify Cluster.
// In the callback implementation, an endpoint can identify itself. (e.g., by flashing an LED or light).
static esp_err_t app_identification_cb(identification::callback_type_t type, uint16_t endpoint_id, uint8_t effect_id,
                                       uint8_t effect_variant, void *priv_data)
{
    ESP_LOGI(TAG, "Identification callback: type: %u, effect: %u, variant: %u", type, effect_id, effect_variant);
    return ESP_OK;
}

// This callback is called for every attribute update. The callback implementation shall
// handle the desired attributes and return an appropriate error code. If the attribute
// is not of your interest, please do not return an error code and strictly return ESP_OK.
static esp_err_t app_attribute_update_cb(attribute::callback_type_t type, uint16_t endpoint_id, uint32_t cluster_id,
                                         uint32_t attribute_id, esp_matter_attr_val_t *val, void *priv_data)
{
    esp_err_t err = ESP_OK;

    if (type == PRE_UPDATE) {
        /* Driver update */
        app_driver_handle_t driver_handle = (app_driver_handle_t)priv_data;
        err = app_driver_attribute_update(driver_handle, endpoint_id, cluster_id, attribute_id, val);
    }

    return err;
}

extern "C" void app_main()
{
    esp_err_t err = ESP_OK;

    /* Initialize the ESP NVS layer */
    nvs_flash_init();

    /* Initialize driver */
    app_driver_handle_t light_handle = app_driver_light_init();
    app_driver_handle_t button_handle = app_driver_button_init();
    app_reset_button_register(button_handle);

    /* Create a Matter node and add the mandatory Root Node device type on endpoint 0 */
    node::config_t node_config;

    // node handle can be used to add/modify other endpoints.
    node_t *node = node::create(&node_config, app_attribute_update_cb, app_identification_cb);
    ABORT_APP_ON_FAILURE(node != nullptr, ESP_LOGE(TAG, "Failed to create Matter node"));

    /*extended_color_light::config_t light_config;
    light_config.on_off.on_off = DEFAULT_POWER;
    light_config.on_off.lighting.start_up_on_off = nullptr;
    light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
    light_config.level_control.on_level = DEFAULT_BRIGHTNESS;
    light_config.level_control.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
    light_config.color_control.color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
    light_config.color_control.enhanced_color_mode = (uint8_t)ColorControl::ColorMode::kColorTemperature;
    light_config.color_control.color_temperature.startup_color_temperature_mireds = nullptr;*/

    dimmable_light::config_t light_config;
    light_config.on_off.on_off = DEFAULT_POWER;
    light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
    light_config.level_control.on_level = DEFAULT_BRIGHTNESS;
    light_config.level_control.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;

    // endpoint handles can be used to add/modify clusters.
    endpoint_t *endpoint = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id);

///////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_1 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_1);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_1);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_2 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_2);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_2);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_3 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_3);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_3);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_4 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_4);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_4);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_5 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_5);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_5);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_6 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_6);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_6);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_7 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_7);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_7);

//////////////////////////////////////////////////////////////////////////

    endpoint_t *endpoint_8 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

    light_endpoint_id = endpoint::get_id(endpoint_8);
    ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_8);

//////////////////////////////////////////////////////////////////////////

endpoint_t *endpoint_9 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

light_endpoint_id = endpoint::get_id(endpoint_9);
ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_9);

//////////////////////////////////////////////////////////////////////////

endpoint_t *endpoint_10 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

light_endpoint_id = endpoint::get_id(endpoint_10);
ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_10);

//////////////////////////////////////////////////////////////////////////

endpoint_t *endpoint_11 = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create extended color light endpoint"));

light_endpoint_id = endpoint::get_id(endpoint_11);
ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id_11);

//////////////////////////////////////////////////////////////////////////

    /* Mark deferred persistence for some attributes that might be changed rapidly 
    attribute_t *current_level_attribute = attribute::get(light_endpoint_id, LevelControl::Id, LevelControl::Attributes::CurrentLevel::Id);
    attribute::set_deferred_persistence(current_level_attribute);

    attribute_t *current_x_attribute = attribute::get(light_endpoint_id, ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
    attribute::set_deferred_persistence(current_x_attribute);
    attribute_t *current_y_attribute = attribute::get(light_endpoint_id, ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
    attribute::set_deferred_persistence(current_y_attribute);
    attribute_t *color_temp_attribute = attribute::get(light_endpoint_id, ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
    attribute::set_deferred_persistence(color_temp_attribute);
*/
#if CHIP_DEVICE_CONFIG_ENABLE_THREAD && CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION
    // Enable secondary network interface
    secondary_network_interface::config_t secondary_network_interface_config;
    endpoint = endpoint::secondary_network_interface::create(node, &secondary_network_interface_config, ENDPOINT_FLAG_NONE, nullptr);
    ABORT_APP_ON_FAILURE(endpoint != nullptr, ESP_LOGE(TAG, "Failed to create secondary network interface endpoint"));
#endif


#if CHIP_DEVICE_CONFIG_ENABLE_THREAD
    /* Set OpenThread platform config */
    esp_openthread_platform_config_t config = {
        .radio_config = ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG(),
        .host_config = ESP_OPENTHREAD_DEFAULT_HOST_CONFIG(),
        .port_config = ESP_OPENTHREAD_DEFAULT_PORT_CONFIG(),
    };
    set_openthread_platform_config(&config);
#endif

#ifdef CONFIG_ENABLE_SET_CERT_DECLARATION_API
    auto * dac_provider = get_dac_provider();
#ifdef CONFIG_SEC_CERT_DAC_PROVIDER
    static_cast<ESP32SecureCertDACProvider *>(dac_provider)->SetCertificationDeclaration(cdSpan);
#elif defined(CONFIG_FACTORY_PARTITION_DAC_PROVIDER)
    static_cast<ESP32FactoryDataProvider *>(dac_provider)->SetCertificationDeclaration(cdSpan);
#endif
#endif // CONFIG_ENABLE_SET_CERT_DECLARATION_API

    /* Matter start */
    err = esp_matter::start(app_event_cb);
    ABORT_APP_ON_FAILURE(err == ESP_OK, ESP_LOGE(TAG, "Failed to start Matter, err:%d", err));

    /* Starting driver with default values */
    app_driver_light_set_defaults(light_endpoint_id);

#if CONFIG_ENABLE_ENCRYPTED_OTA
    err = esp_matter_ota_requestor_encrypted_init(s_decryption_key, s_decryption_key_len);
    ABORT_APP_ON_FAILURE(err == ESP_OK, ESP_LOGE(TAG, "Failed to initialized the encrypted OTA, err: %d", err));
#endif // CONFIG_ENABLE_ENCRYPTED_OTA

#if CONFIG_ENABLE_CHIP_SHELL
    esp_matter::console::diagnostics_register_commands();
    esp_matter::console::wifi_register_commands();
    esp_matter::console::factoryreset_register_commands();
#if CONFIG_OPENTHREAD_CLI
    esp_matter::console::otcli_register_commands();
#endif
    esp_matter::console::init();
#endif
}

driver code

/*
   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

#include <esp_log.h>
#include <stdlib.h>
#include <string.h>

#include <esp_matter.h>
#include "bsp/esp-bsp.h"

#include <app_priv.h>

#include "driver/gpio.h"
#include "driver/i2c.h"
#include "driver/i2c_master.h"

#define I2C_MASTER_SCL_IO   8
#define I2C_MASTER_SDA_IO   10
#define I2C_MASTER_FREQ_HZ  400000
//#define 12C_MASTER_NUM      I2C_NUM_0

using namespace chip::app::Clusters;
using namespace esp_matter;

static const char *TAG = "app_driver";
extern uint16_t light_endpoint_id;
extern uint16_t light_endpoint_id_1;
extern uint16_t light_endpoint_id_2;
extern uint16_t light_endpoint_id_3;
extern uint16_t light_endpoint_id_4;
extern uint16_t light_endpoint_id_5;
extern uint16_t light_endpoint_id_6;
extern uint16_t light_endpoint_id_7;
extern uint16_t light_endpoint_id_8;
extern uint16_t light_endpoint_id_9;
extern uint16_t light_endpoint_id_10;
extern uint16_t light_endpoint_id_11;


void i2c_init(void){
    
    i2c_config_t confi2c = {
        .mode = I2C_MODE_MASTER, 
        .sda_io_num = I2C_MASTER_SDA_IO,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master = { .clk_speed = I2C_MASTER_FREQ_HZ } // Correcte initialisatie
    };

    i2c_param_config(I2C_NUM_0, &confi2c);
    i2c_driver_install(I2C_NUM_0,confi2c.mode,0,0,0);

}

void i2c_write_data(uint8_t byte1, uint8_t byte2) {
    uint8_t data[2] = {byte1, byte2};

    esp_err_t err = i2c_master_write_to_device (
        I2C_NUM_0,
        0x30,
        data,
        sizeof(data),
        pdMS_TO_TICKS(1000)
    );

    if(err != ESP_OK) {
        printf("I2C write failed: %s\n", esp_err_to_name(err));
    }
}

/* Do any conversions/remapping for the actual value here */
static esp_err_t app_driver_light_set_power(led_indicator_handle_t handle, esp_matter_attr_val_t *val)
{
#if CONFIG_BSP_LEDS_NUM > 0
    esp_err_t err = ESP_OK;
    if (val->val.b) {
        err = led_indicator_start(handle, BSP_LED_ON);
    } else {
        err = led_indicator_start(handle, BSP_LED_OFF);
    }
    return err;
#else
    ESP_LOGI(TAG, "LED set power: %d", val->val.b);
    return ESP_OK;
#endif
}

static esp_err_t app_driver_light_set_brightness(led_indicator_handle_t handle, esp_matter_attr_val_t *val)
{
    int value = REMAP_TO_RANGE(val->val.u8, MATTER_BRIGHTNESS, STANDARD_BRIGHTNESS);
#if CONFIG_BSP_LEDS_NUM > 0
    return led_indicator_set_brightness(handle, value);
#else
    ESP_LOGI(TAG, "LED set brightness: %d", value);
    return ESP_OK;
#endif
}

static esp_err_t app_driver_light_set_hue(led_indicator_handle_t handle, esp_matter_attr_val_t *val)
{
    int value = REMAP_TO_RANGE(val->val.u8, MATTER_HUE, STANDARD_HUE);
#if CONFIG_BSP_LEDS_NUM > 0
    led_indicator_ihsv_t hsv;
    hsv.value = led_indicator_get_hsv(handle);
    hsv.h = value;
    return led_indicator_set_hsv(handle, hsv.value);
#else
    ESP_LOGI(TAG, "LED set hue: %d", value);
    return ESP_OK;
#endif
}

static esp_err_t app_driver_light_set_saturation(led_indicator_handle_t handle, esp_matter_attr_val_t *val)
{
    int value = REMAP_TO_RANGE(val->val.u8, MATTER_SATURATION, STANDARD_SATURATION);
#if CONFIG_BSP_LEDS_NUM > 0
    led_indicator_ihsv_t hsv;
    hsv.value = led_indicator_get_hsv(handle);
    hsv.s = value;
    return led_indicator_set_hsv(handle, hsv.value);
#else
    ESP_LOGI(TAG, "LED set saturation: %d", value);
    return ESP_OK;
#endif
}

static esp_err_t app_driver_light_set_temperature(led_indicator_handle_t handle, esp_matter_attr_val_t *val)
{
    uint32_t value = REMAP_TO_RANGE_INVERSE(val->val.u16, STANDARD_TEMPERATURE_FACTOR);
#if CONFIG_BSP_LEDS_NUM > 0
    return led_indicator_set_color_temperature(handle, value);
#else
    ESP_LOGI(TAG, "LED set temperature: %ld", value);
    return ESP_OK;
#endif
}

static void app_driver_button_toggle_cb(void *arg, void *data)
{
    ESP_LOGI(TAG, "Toggle button pressed");
    uint16_t endpoint_id = light_endpoint_id;
    uint32_t cluster_id = OnOff::Id;
    uint32_t attribute_id = OnOff::Attributes::OnOff::Id;

    attribute_t *attribute = attribute::get(endpoint_id, cluster_id, attribute_id);

    esp_matter_attr_val_t val = esp_matter_invalid(NULL);
    attribute::get_val(attribute, &val);
    val.val.b = !val.val.b;
    attribute::update(endpoint_id, cluster_id, attribute_id, &val);
}

/*esp_err_t app_driver_attribute_update(app_driver_handle_t driver_handle, uint16_t endpoint_id, uint32_t cluster_id,
                                      uint32_t attribute_id, esp_matter_attr_val_t *val)
{
    esp_err_t err = ESP_OK;
    if (endpoint_id == light_endpoint_id) {
        led_indicator_handle_t handle = (led_indicator_handle_t)driver_handle;
        if (cluster_id == OnOff::Id) {
            if (attribute_id == OnOff::Attributes::OnOff::Id) {
                err = app_driver_light_set_power(handle, val);
            }
        } else if (cluster_id == LevelControl::Id) {
            if (attribute_id == LevelControl::Attributes::CurrentLevel::Id) {
                err = app_driver_light_set_brightness(handle, val);
            }
        } else if (cluster_id == ColorControl::Id) {
            if (attribute_id == ColorControl::Attributes::CurrentHue::Id) {
                err = app_driver_light_set_hue(handle, val);
            } else if (attribute_id == ColorControl::Attributes::CurrentSaturation::Id) {
                err = app_driver_light_set_saturation(handle, val);
            } else if (attribute_id == ColorControl::Attributes::ColorTemperatureMireds::Id) {
                err = app_driver_light_set_temperature(handle, val);
            }
        }
    }
    return err;
}*/

esp_err_t app_driver_attribute_update(app_driver_handle_t driver_handle, uint16_t endpoint_id, uint32_t cluster_id,
    uint32_t attribute_id, esp_matter_attr_val_t *val)
{
    esp_err_t err = ESP_OK;
    if (endpoint_id == light_endpoint_id) 
    {
        if(cluster_id == LevelControl::Id)
        {
            if(attribute_id == LevelControl::Attributes::CurrentLevel::Id)
            {
                i2c_write_data(0xFE, 0xC5);
                i2c_write_data(0xFD, 0x04);
                i2c_write_data(0x00, 0x01);
                i2c_write_data(0x01, 0xFF);

                uint8_t tempVal = val->val.u8;    //problem with using the 

                for(uint8_t i=0; i < tempVal; i++)
                {
                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x02);
                    i2c_write_data(i, 0x0F);

                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x00);
                    i2c_write_data(i, 0xFF);
                }

                for(int i=100-tempVal; i<=100; i++)
                {
                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x02);
                    i2c_write_data(i, 0x0F);

                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x00);
                    i2c_write_data(i, 0xFF);
                }
            }
        }
    }

    if (endpoint_id == light_endpoint_id_1) 
    {
        if(cluster_id == LevelControl::Id)
        {
            if(attribute_id == LevelControl::Attributes::CurrentLevel::Id)
            {
                i2c_write_data(0xFE, 0xC5);
                i2c_write_data(0xFD, 0x04);
                i2c_write_data(0x00, 0x01);
                i2c_write_data(0x01, 0xFF);

                uint8_t tempVal = val->val.u8;    //problem with using the 

                for(uint8_t i=0; i < tempVal; i++)
                {
                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x02);
                    i2c_write_data(i, 0x0F);

                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x00);
                    i2c_write_data(i, 0xFF);
                }

                for(int i=100-tempVal; i<=100; i++)
                {
                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x02);
                    i2c_write_data(i, 0x0F);

                    i2c_write_data(0xFE, 0xC5);
                    i2c_write_data(0xFD, 0x00);
                    i2c_write_data(i, 0xFF);
                }
            }
        }
    }

    if (endpoint_id == light_endpoint_id_2) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val == on)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_15, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_15, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_3) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_23, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_23, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_4) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_22, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_22, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_5) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_21, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_21, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_6) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_20, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_20, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_7) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_16, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_16, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_8) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_18, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_18, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_9) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_9, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_9, 0);
                }
            }

        } 
    }
    if (endpoint_id == light_endpoint_id_10) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_13, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_13, 0);
                }
            }

        } 
    }

    if (endpoint_id == light_endpoint_id_11) {
        if(cluster_id == OnOff::Id)
        {
            if(attribute_id == OnOff::Attributes::OnOff::Id)
            {
                if(val)     //TRue or false
                {
                    gpio_set_level(GPIO_NUM_12, 1);
                } 
                else 
                {
                    gpio_set_level(GPIO_NUM_12, 0);
                }
            }

        } 
    }


    return err;
}


esp_err_t app_driver_light_set_defaults(uint16_t endpoint_id)
{
    esp_err_t err = ESP_OK;
    void *priv_data = endpoint::get_priv_data(endpoint_id);
    led_indicator_handle_t handle = (led_indicator_handle_t)priv_data;
    esp_matter_attr_val_t val = esp_matter_invalid(NULL);

    /* Setting brightness */
    attribute_t *attribute = attribute::get(endpoint_id, LevelControl::Id, LevelControl::Attributes::CurrentLevel::Id);
    attribute::get_val(attribute, &val);
    err |= app_driver_light_set_brightness(handle, &val);

    /* Setting color */
    attribute = attribute::get(endpoint_id, ColorControl::Id, ColorControl::Attributes::ColorMode::Id);
    attribute::get_val(attribute, &val);
    if (val.val.u8 == (uint8_t)ColorControl::ColorMode::kCurrentHueAndCurrentSaturation) {
        /* Setting hue */
        attribute = attribute::get(endpoint_id, ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
        attribute::get_val(attribute, &val);
        err |= app_driver_light_set_hue(handle, &val);
        /* Setting saturation */
        attribute = attribute::get(endpoint_id, ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
        attribute::get_val(attribute, &val);
        err |= app_driver_light_set_saturation(handle, &val);
    } else if (val.val.u8 == (uint8_t)ColorControl::ColorMode::kColorTemperature) {
        /* Setting temperature */
        attribute = attribute::get(endpoint_id, ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
        attribute::get_val(attribute, &val);
        err |= app_driver_light_set_temperature(handle, &val);
    } else {
        ESP_LOGE(TAG, "Color mode not supported");
    }

    /* Setting power */
    attribute = attribute::get(endpoint_id, OnOff::Id, OnOff::Attributes::OnOff::Id);
    attribute::get_val(attribute, &val);
    err |= app_driver_light_set_power(handle, &val);

    return err;
}

app_driver_handle_t app_driver_light_init()
{

    gpio_set_direction(GPIO_NUM_15, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_23, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_22, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_21, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_20, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_16, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_18, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_9, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_13, GPIO_MODE_OUTPUT);
    gpio_set_direction(GPIO_NUM_12, GPIO_MODE_OUTPUT);



#if CONFIG_BSP_LEDS_NUM > 0
    /* Initialize led */
    led_indicator_handle_t leds[CONFIG_BSP_LEDS_NUM];
    ESP_ERROR_CHECK(bsp_led_indicator_create(leds, NULL, CONFIG_BSP_LEDS_NUM));
    led_indicator_set_hsv(leds[0], SET_HSV(DEFAULT_HUE, DEFAULT_SATURATION, DEFAULT_BRIGHTNESS));
    
    return (app_driver_handle_t)leds[0];
#else
    return NULL;
#endif
}

app_driver_handle_t app_driver_button_init()
{
    /* Initialize button */
    button_handle_t btns[BSP_BUTTON_NUM];
    ESP_ERROR_CHECK(bsp_iot_button_create(btns, NULL, BSP_BUTTON_NUM));
    ESP_ERROR_CHECK(iot_button_register_cb(btns[0], BUTTON_PRESS_DOWN, app_driver_button_toggle_cb, NULL));
    
    return (app_driver_handle_t)btns[0];
}

[karthi03857]

// Ensure this function is properly handling attribute updates based on type, cluster, and attribute ID.
static esp_err_t app_attribute_update_cb(attribute::callback_type_t type, uint16_t endpoint_id, uint32_t cluster_id,
uint32_t attribute_id, esp_matter_attr_val_t *val, void *priv_data)
{
esp_err_t err = ESP_OK;

if (type == PRE_UPDATE) {
    /* Driver update */
    app_driver_handle_t driver_handle = (app_driver_handle_t)priv_data;

    // TODO: Add more logging if debugging is required for specific cluster updates.
    ESP_LOGI(TAG, "Attribute Update - Endpoint: %d, Cluster: %d, Attribute: %d", endpoint_id, cluster_id, attribute_id);

    // FIXME: Ensure 'val' is not null before accessing its members.
    if (!val) {
        ESP_LOGE(TAG, "Received NULL value for attribute update!");
        return ESP_FAIL; // Prevent accessing null pointer
    }

    // Handling OnOff cluster attribute updates
    if (cluster_id == OnOff::Id && attribute_id == OnOff::Attributes::OnOff::Id) {
        // REVIEW: Confirm that boolean value (val->val.b) correctly reflects the device state.
        ESP_LOGI(TAG, "OnOff Value: %d", val->val.b);
    }

    // Handling LevelControl cluster attribute updates
    if (cluster_id == LevelControl::Id && attribute_id == LevelControl::Attributes::CurrentLevel::Id) {
        // CHECK: Ensure the value is within the expected range (0-100).
        ESP_LOGI(TAG, "LevelControl Value: %d", val->val.u8);
    }

    err = app_driver_attribute_update(driver_handle, endpoint_id, cluster_id, attribute_id, val);
}

return err;

}
TODO: Suggests adding more logging if debugging is needed.
FIXME: Highlights a potential issue where val might be null and needs checking.
REVIEW: Asks for verification of the OnOff value behavior.
CHECK: Ensures LevelControl values stay within the expected range.

[ravencarcass]

well since wednesday did it works and could I add some more function in name of I2C. But their are a few things that I find weird. I would like to add 3 GPIO's and 2 ledc pins. But if I add the initialization(timer and channel) of ledc does it report the next: out-of-order initializers are nonstandard in C++. If I test this apart from the matter application works it seamless, what is weird. I escaped the init for the ledc and it worked but once I add the ledc to it gives it me some problem.

void periferal_init(void){
    i2c_config_t confi2c = {
        .mode = I2C_MODE_MASTER, 
        .sda_io_num = I2C_MASTER_SDA_IO,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master = { .clk_speed = I2C_MASTER_FREQ_HZ } // Correcte initialisatie
    };

    i2c_param_config(I2C_NUM_0, &confi2c);
    i2c_driver_install(I2C_NUM_0,confi2c.mode,0,0,0);

    ledc_timer_config_t timer = {
        .speed_mode         = LEDC_LOW_SPEED_MODE,
        .timer_num          = LEDC_TIMER_1,
        .duty_resolution    = LEDC_TIMER_13_BIT,
        .freq_hz            = 500,
        .clk_cfg            = LEDC_AUTO_CLK
    };
    ledc_timer_config(&timer);

    ledc_channel_config_t channel = {
        .gpio_num       = 10,
        .speed_mode     = LEDC_LOW_SPEED_MODE,
        .channel        = LEDC_CHANNEL_1,
        .intr_type      = LEDC_INTR_DISABLE,
        .timer_sel      = LEDC_TIMER_1,
        .duty           = DUTY,
        .hpoint         = 0
    };
    ledc_channel_config(&channel);
}