led_driver: Add support for handle

app_main: Passing this handle to the endpoint as priv_data and using the handle in the driver on attribute_update.

device_hal/led_driver/gpio/led_driver.c

@@ -21,7 +21,7 @@ static const char *TAG = "led_driver_gpio";
 static bool current_power = false;
 static uint8_t current_brightness = 0;
 
-esp_err_t led_driver_init(led_driver_config_t *config)
+led_driver_handle_t led_driver_init(led_driver_config_t *config)
 {
     ESP_LOGI(TAG, "Initializing light driver");
     esp_err_t err = ESP_OK;
@@ -36,7 +36,7 @@ esp_err_t led_driver_init(led_driver_config_t *config)
     err = ledc_timer_config(&ledc_timer);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "led_timerc_config failed");
-        return err;
+        return NULL;
     }
 
     ledc_channel_config_t ledc_channel = {
@@ -53,18 +53,24 @@ esp_err_t led_driver_init(led_driver_config_t *config)
         ESP_LOGE(TAG, "ledc_channel_config failed");
     }
 
-    return err;
+    /* Using (channel + 1) as handle */
+    return (led_driver_handle_t)(config->channel + 1);
 }
 
-esp_err_t led_driver_set_power(bool power)
+esp_err_t led_driver_set_power(led_driver_handle_t handle, bool power)
 {
     current_power = power;
-    return led_driver_set_brightness(current_brightness);
+    return led_driver_set_brightness(handle, current_brightness);
 }
 
-esp_err_t led_driver_set_brightness(uint8_t brightness)
+esp_err_t led_driver_set_brightness(led_driver_handle_t handle, uint8_t brightness)
 {
     esp_err_t err;
+    int channel = (int)handle - 1;
+    if (channel < 0) {
+        ESP_LOGE(TAG, "Invalid handle");
+        return ESP_ERR_INVALID_ARG;
+    }
 
     if (brightness != 0) {
         current_brightness = brightness;
@@ -73,54 +79,54 @@ esp_err_t led_driver_set_brightness(uint8_t brightness)
         brightness = 0;
     }
 
-    err = ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, brightness);
+    err = ledc_set_duty(LEDC_LOW_SPEED_MODE, channel, brightness);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "ledc_set_duty failed");
     }
 
-    err = ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0);
+    err = ledc_update_duty(LEDC_LOW_SPEED_MODE, channel);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "ledc_update_duty failed");
     }
     return err;
 }
 
-esp_err_t led_driver_set_hue(uint16_t hue)
+esp_err_t led_driver_set_hue(led_driver_handle_t handle, uint16_t hue)
 {
     return ESP_ERR_NOT_SUPPORTED;
 }
 
-esp_err_t led_driver_set_saturation(uint8_t saturation)
+esp_err_t led_driver_set_saturation(led_driver_handle_t handle, uint8_t saturation)
 {
     return ESP_ERR_NOT_SUPPORTED;
 }
 
-esp_err_t led_driver_set_temperature(uint32_t temperature)
+esp_err_t led_driver_set_temperature(led_driver_handle_t handle, uint32_t temperature)
 {
     return ESP_ERR_NOT_SUPPORTED;
 }
 
-bool led_driver_get_power()
+bool led_driver_get_power(led_driver_handle_t handle)
 {
     return current_power;
 }
 
-uint8_t led_driver_get_brightness()
+uint8_t led_driver_get_brightness(led_driver_handle_t handle)
 {
     return current_brightness;
 }
 
-uint16_t led_driver_get_hue()
+uint16_t led_driver_get_hue(led_driver_handle_t handle)
 {
     return 0;
 }
 
-uint8_t led_driver_get_saturation()
+uint8_t led_driver_get_saturation(led_driver_handle_t handle)
 {
     return 0;
 }
 
-uint32_t led_driver_get_temperature()
+uint32_t led_driver_get_temperature(led_driver_handle_t handle)
 {
     return 0;
 }

device_hal/led_driver/hollow_led/led_driver.c

@@ -21,15 +21,15 @@ static uint8_t current_brightness = 0;
 static HS_color_t current_HS = {0, 0};
 static uint32_t current_temperature = 6600;
 
-esp_err_t led_driver_init(led_driver_config_t *config)
+led_driver_handle_t led_driver_init(led_driver_config_t *config)
 {
     ESP_LOGI(TAG, "Initializing light driver");
     /* Initialize the driver here */
 
-    return ESP_OK;
+    return NULL;
 }
 
-esp_err_t led_driver_set_power(bool power)
+esp_err_t led_driver_set_power(led_driver_handle_t handle, bool power)
 {
     ESP_LOGI(TAG, "Setting power to: %d", power);
     /* Set the power state here */
@@ -37,7 +37,7 @@ esp_err_t led_driver_set_power(bool power)
     return ESP_OK;
 }
 
-esp_err_t led_driver_set_brightness(uint8_t brightness)
+esp_err_t led_driver_set_brightness(led_driver_handle_t handle, uint8_t brightness)
 {
     ESP_LOGI(TAG, "Setting brightness to: %d", brightness);
     /* Set the brightness level here */
@@ -45,7 +45,7 @@ esp_err_t led_driver_set_brightness(uint8_t brightness)
     return ESP_OK;
 }
 
-esp_err_t led_driver_set_hue(uint16_t hue)
+esp_err_t led_driver_set_hue(led_driver_handle_t handle, uint16_t hue)
 {
     ESP_LOGI(TAG, "Setting hue to: %d", hue);
     /* Set the color hue here */
@@ -53,7 +53,7 @@ esp_err_t led_driver_set_hue(uint16_t hue)
     return ESP_OK;
 }
 
-esp_err_t led_driver_set_saturation(uint8_t saturation)
+esp_err_t led_driver_set_saturation(led_driver_handle_t handle, uint8_t saturation)
 {
     ESP_LOGI(TAG, "Setting saturation to: %d", saturation);
     /* Set the color saturation here */
@@ -61,7 +61,7 @@ esp_err_t led_driver_set_saturation(uint8_t saturation)
     return ESP_OK;
 }
 
-esp_err_t led_driver_set_temperature(uint32_t temperature)
+esp_err_t led_driver_set_temperature(led_driver_handle_t handle, uint32_t temperature)
 {
     ESP_LOGI(TAG, "Setting temperature to: %d", temperature);
     /* Set the color temp here*/
@@ -69,27 +69,27 @@ esp_err_t led_driver_set_temperature(uint32_t temperature)
     return ESP_OK;
 }
 
-bool led_driver_get_power()
+bool led_driver_get_power(led_driver_handle_t handle)
 {
     return current_power;
 }
 
-uint8_t led_driver_get_brightness()
+uint8_t led_driver_get_brightness(led_driver_handle_t handle)
 {
     return current_brightness;
 }
 
-uint16_t led_driver_get_hue()
+uint16_t led_driver_get_hue(led_driver_handle_t handle)
 {
     return current_HS.hue;
 }
 
-uint8_t led_driver_get_saturation()
+uint8_t led_driver_get_saturation(led_driver_handle_t handle)
 {
     return current_HS.saturation;
 }
 
-uint32_t led_driver_get_temperature()
+uint32_t led_driver_get_temperature(led_driver_handle_t handle)
 {
     return current_temperature;
 }

device_hal/led_driver/include/led_driver.h

@@ -25,18 +25,20 @@ typedef struct {
     int channel;
 } led_driver_config_t;
 
-esp_err_t led_driver_init(led_driver_config_t *config);
-esp_err_t led_driver_set_power(bool power);
-esp_err_t led_driver_set_brightness(uint8_t brightness);
-esp_err_t led_driver_set_hue(uint16_t hue);
-esp_err_t led_driver_set_saturation(uint8_t saturation);
-esp_err_t led_driver_set_temperature(uint32_t temperature);
+typedef void *led_driver_handle_t;
 
-bool led_driver_get_power(void);
-uint8_t led_driver_get_brightness(void);
-uint16_t led_driver_get_hue(void);
-uint8_t led_driver_get_saturation(void);
-uint32_t led_driver_get_temperature(void);
+led_driver_handle_t led_driver_init(led_driver_config_t *config);
+esp_err_t led_driver_set_power(led_driver_handle_t handle, bool power);
+esp_err_t led_driver_set_brightness(led_driver_handle_t handle, uint8_t brightness);
+esp_err_t led_driver_set_hue(led_driver_handle_t handle, uint16_t hue);
+esp_err_t led_driver_set_saturation(led_driver_handle_t handle, uint8_t saturation);
+esp_err_t led_driver_set_temperature(led_driver_handle_t handle, uint32_t temperature);
+
+bool led_driver_get_power(led_driver_handle_t handle);
+uint8_t led_driver_get_brightness(led_driver_handle_t handle);
+uint16_t led_driver_get_hue(led_driver_handle_t handle);
+uint8_t led_driver_get_saturation(led_driver_handle_t handle);
+uint32_t led_driver_get_temperature(led_driver_handle_t handle);
 
 #ifdef __cplusplus
 }

device_hal/led_driver/vled/led_driver.c

@@ -124,32 +124,43 @@ static esp_err_t InitDisplay()
     return ESP_OK;
 }
 
-esp_err_t led_driver_init(led_driver_config_t *config)
+led_driver_handle_t led_driver_init(led_driver_config_t *config)
 {
+    static bool init_done = false;
+    if (init_done) {
+        ESP_LOGE(TAG, "This led driver only supports one led initialisation.");
+        return NULL;
+    }
     ESP_LOGI(TAG, "Initializing led driver");
     esp_err_t err = ESP_OK;
     err = InitDisplay();
     if (err != ESP_OK) {
-        return err;
+        return NULL;
     }
     SetupBrightnessControl(config);
     SetDisplayBrightness(BRIGHTNESS_MAX);
-    return err;
+    init_done = true;
+
+    /* Temporary handle. Not being used anywhere. */
+    static int handle = 1;
+    return (led_driver_handle_t)handle;
 }
 
-esp_err_t led_driver_set_power(bool power)
+esp_err_t led_driver_set_power(led_driver_handle_t handle, bool power)
 {
     current_power = power;
-    return led_driver_set_brightness(current_brightness);
+    return led_driver_set_brightness(handle, current_brightness);
 }
-esp_err_t led_driver_set_RGB()
+
+esp_err_t led_driver_set_RGB(led_driver_handle_t handle)
 {
     TFT_fillWindow(TFT_BLACK);
     TFT_fillCircle(DisplayWidth / 2, DisplayHeight / 2, DisplayWidth / 4, (color_t){mRGB.red, mRGB.green, mRGB.blue});
     TFT_drawCircle(DisplayWidth / 2, DisplayHeight / 2, DisplayWidth / 4, (color_t){255, 255, 255});
     return ESP_OK;
 }
-esp_err_t led_driver_set_brightness(uint8_t brightness)
+
+esp_err_t led_driver_set_brightness(led_driver_handle_t handle, uint8_t brightness)
 {
     if (brightness != 0) {
         current_brightness = brightness;
@@ -158,55 +169,55 @@ esp_err_t led_driver_set_brightness(uint8_t brightness)
         brightness = 0;
     }
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-esp_err_t led_driver_set_hue(uint16_t hue)
+esp_err_t led_driver_set_hue(led_driver_handle_t handle, uint16_t hue)
 {
     uint8_t brightness = current_power ? current_brightness : 0;
     current_HS.hue = hue;
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-esp_err_t led_driver_set_saturation(uint8_t saturation)
+esp_err_t led_driver_set_saturation(led_driver_handle_t handle, uint8_t saturation)
 {
     uint8_t brightness = current_power ? current_brightness : 0;
     current_HS.saturation = saturation;
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-esp_err_t led_driver_set_temperature(uint32_t temperature)
+esp_err_t led_driver_set_temperature(led_driver_handle_t handle, uint32_t temperature)
 {
     uint8_t brightness = current_power ? current_brightness : 0;
     current_temperature = temperature;
     temp_to_hs(current_temperature, &current_HS);
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-bool led_driver_get_power()
+bool led_driver_get_power(led_driver_handle_t handle)
 {
     return current_power;
 }
 
-uint8_t led_driver_get_brightness()
+uint8_t led_driver_get_brightness(led_driver_handle_t handle)
 {
     return current_brightness;
 }
 
-uint16_t led_driver_get_hue()
+uint16_t led_driver_get_hue(led_driver_handle_t handle)
 {
     return current_HS.hue;
 }
 
-uint8_t led_driver_get_saturation()
+uint8_t led_driver_get_saturation(led_driver_handle_t handle)
 {
     return current_HS.saturation;
 }
 
-uint32_t led_driver_get_temperature()
+uint32_t led_driver_get_temperature(led_driver_handle_t handle)
 {
     return current_temperature;
 }

device_hal/led_driver/ws2812/led_driver.c

@@ -23,9 +23,8 @@ static uint8_t current_brightness = 0;
 static uint32_t current_temp = 6600;
 static HS_color_t current_HS = {0, 0};
 static RGB_color_t mRGB;
-static led_strip_t *strip = NULL;
 
-esp_err_t led_driver_init(led_driver_config_t *config)
+led_driver_handle_t led_driver_init(led_driver_config_t *config)
 {
     ESP_LOGI(TAG, "Initializing light driver");
     esp_err_t err = ESP_OK;
@@ -42,27 +41,28 @@ esp_err_t led_driver_init(led_driver_config_t *config)
     }
 
     led_strip_config_t strip_config = LED_STRIP_DEFAULT_CONFIG(1, (led_strip_dev_t)rmt_cfg.channel);
-    strip = led_strip_new_rmt_ws2812(&strip_config);
+    led_strip_t *strip = led_strip_new_rmt_ws2812(&strip_config);
     if (!strip) {
         ESP_LOGE(TAG, "W2812 driver install failed");
         err = ESP_FAIL;
     }
-    return err;
+    return (led_driver_handle_t)strip;
 }
 
-esp_err_t led_driver_set_power(bool power)
+esp_err_t led_driver_set_power(led_driver_handle_t handle, bool power)
 {
     current_power = power;
-    return led_driver_set_brightness(current_brightness);
+    return led_driver_set_brightness(handle, current_brightness);
 }
 
-esp_err_t led_driver_set_RGB()
+esp_err_t led_driver_set_RGB(led_driver_handle_t handle)
 {
     esp_err_t err = ESP_OK;
-    if (!strip) {
-        ESP_LOGE(TAG, "can't find w2812 led_strip handle");
+    if (!handle) {
+        ESP_LOGE(TAG, "led driver handle cannot be NULL");
         err = ESP_FAIL;
     } else {
+        led_strip_t *strip = (led_strip_t *)handle;
         err = strip->set_pixel(strip, 0, mRGB.red, mRGB.green, mRGB.blue);
         if (err != ESP_OK) {
             ESP_LOGE(TAG, "strip_set_pixel failed");
@@ -77,7 +77,7 @@ esp_err_t led_driver_set_RGB()
     return err;
 }
 
-esp_err_t led_driver_set_brightness(uint8_t brightness)
+esp_err_t led_driver_set_brightness(led_driver_handle_t handle, uint8_t brightness)
 {
     if (brightness != 0) {
         current_brightness = brightness;
@@ -86,55 +86,55 @@ esp_err_t led_driver_set_brightness(uint8_t brightness)
         brightness = 0;
     }
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-esp_err_t led_driver_set_hue(uint16_t hue)
+esp_err_t led_driver_set_hue(led_driver_handle_t handle, uint16_t hue)
 {
     uint8_t brightness = current_power ? current_brightness : 0;
     current_HS.hue = hue;
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-esp_err_t led_driver_set_saturation(uint8_t saturation)
+esp_err_t led_driver_set_saturation(led_driver_handle_t handle, uint8_t saturation)
 {
     uint8_t brightness = current_power ? current_brightness : 0;
     current_HS.saturation = saturation;
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-esp_err_t led_driver_set_temperature(uint32_t temperature)
+esp_err_t led_driver_set_temperature(led_driver_handle_t handle, uint32_t temperature)
 {
     uint8_t brightness = current_power ? current_brightness : 0;
     current_temp = temperature;
     temp_to_hs(current_temp, &current_HS);
     hsv_to_rgb(current_HS, brightness, &mRGB);
-    return led_driver_set_RGB();
+    return led_driver_set_RGB(handle);
 }
 
-bool led_driver_get_power()
+bool led_driver_get_power(led_driver_handle_t handle)
 {
     return current_power;
 }
 
-uint8_t led_driver_get_brightness()
+uint8_t led_driver_get_brightness(led_driver_handle_t handle)
 {
     return current_brightness;
 }
 
-uint16_t led_driver_get_hue()
+uint16_t led_driver_get_hue(led_driver_handle_t handle)
 {
     return current_HS.hue;
 }
 
-uint8_t led_driver_get_saturation()
+uint8_t led_driver_get_saturation(led_driver_handle_t handle)
 {
     return current_HS.saturation;
 }
 
-uint32_t led_driver_get_temperature()
+uint32_t led_driver_get_temperature(led_driver_handle_t handle)
 {
     return current_temp;
 }

examples/common/app_reset/app_reset.cpp

@@ -34,10 +34,15 @@ static void button_factory_reset_released_cb(void *arg)
     }
 }
 
-esp_err_t app_reset_button_register(button_handle_t handle)
+esp_err_t app_reset_button_register(void *handle)
 {
+    if (!handle) {
+        ESP_LOGE(TAG, "Handle cannot be NULL");
+        return ESP_ERR_INVALID_ARG;
+    }
+    button_handle_t button_handle = (button_handle_t)handle;
     esp_err_t err = ESP_OK;
-    err |= iot_button_register_cb(handle, BUTTON_LONG_PRESS_HOLD, button_factory_reset_pressed_cb);
-    err |= iot_button_register_cb(handle, BUTTON_PRESS_UP, button_factory_reset_released_cb);
+    err |= iot_button_register_cb(button_handle, BUTTON_LONG_PRESS_HOLD, button_factory_reset_pressed_cb);
+    err |= iot_button_register_cb(button_handle, BUTTON_PRESS_UP, button_factory_reset_released_cb);
     return err;
 }

examples/common/app_reset/app_reset.h

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <device.h>
+#include <esp_err.h>
 
 /** Register callbacks for Factory reset
  *
@@ -19,4 +19,4 @@
  * @return ESP_OK on success.
  * @return error in case of failure.
  */
-esp_err_t app_reset_button_register(button_handle_t handle);
+esp_err_t app_reset_button_register(void *handle);

examples/light/main/app_driver.cpp

@@ -14,7 +14,6 @@
 #include <esp_matter.h>
 #include <led_driver.h>
 
-#include <app_reset.h>
 #include <app_priv.h>
 
 using namespace chip::app::Clusters;
@@ -24,33 +23,33 @@ static const char *TAG = "app_driver";
 extern uint16_t light_endpoint_id;
 
 /* Do any conversions/remapping for the actual value here */
-static esp_err_t app_driver_light_set_power(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_power(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
-    return led_driver_set_power(val->val.b);
+    return led_driver_set_power(handle, val->val.b);
 }
 
-static esp_err_t app_driver_light_set_brightness(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_brightness(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     int value = REMAP_TO_RANGE(val->val.u8, MATTER_BRIGHTNESS, STANDARD_BRIGHTNESS);
-    return led_driver_set_brightness(value);
+    return led_driver_set_brightness(handle, value);
 }
 
-static esp_err_t app_driver_light_set_hue(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_hue(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     int value = REMAP_TO_RANGE(val->val.u8, MATTER_HUE, STANDARD_HUE);
-    return led_driver_set_hue(value);
+    return led_driver_set_hue(handle, value);
 }
 
-static esp_err_t app_driver_light_set_saturation(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_saturation(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     int value = REMAP_TO_RANGE(val->val.u8, MATTER_SATURATION, STANDARD_SATURATION);
-    return led_driver_set_saturation(value);
+    return led_driver_set_saturation(handle, value);
 }
 
-static esp_err_t app_driver_light_set_temperature(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_temperature(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     uint32_t value = REMAP_TO_RANGE_INVERSE(val->val.u16, STANDARD_TEMPERATURE_FACTOR);
-    return led_driver_set_temperature(value);
+    return led_driver_set_temperature(handle, value);
 }
 
 static void app_driver_button_toggle_cb(void *arg)
@@ -72,32 +71,33 @@ static void app_driver_button_toggle_cb(void *arg)
 }
 
 esp_err_t app_driver_attribute_update(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
-                                      esp_matter_attr_val_t *val)
+                                      esp_matter_attr_val_t *val, void *priv_data)
 {
     esp_err_t err = ESP_OK;
     if (endpoint_id == light_endpoint_id) {
+        led_driver_handle_t handle = (led_driver_handle_t)priv_data;
         if (cluster_id == OnOff::Id) {
             if (attribute_id == OnOff::Attributes::OnOff::Id) {
-                err = app_driver_light_set_power(val);
+                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(val);
+                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(val);
+                err = app_driver_light_set_hue(handle, val);
             } else if (attribute_id == ColorControl::Attributes::CurrentSaturation::Id) {
-                err = app_driver_light_set_saturation(val);
+                err = app_driver_light_set_saturation(handle, val);
             } else if (attribute_id == ColorControl::Attributes::ColorTemperature::Id) {
-                err = app_driver_light_set_temperature(val);
+                err = app_driver_light_set_temperature(handle, val);
             }
         }
     }
     return err;
 }
 
-static esp_err_t app_driver_attribute_set_defaults()
+esp_err_t app_driver_attribute_set_defaults()
 {
     /* Get the default value (current value) from esp_matter and update the app_driver */
     esp_err_t err = ESP_OK;
@@ -113,7 +113,8 @@ static esp_err_t app_driver_attribute_set_defaults()
                 uint32_t attribute_id = attribute::get_id(attribute);
                 esp_matter_attr_val_t val = esp_matter_invalid(NULL);
                 err |= attribute::get_val(attribute, &val);
-                err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+                void *priv_data = endpoint::get_priv_data(endpoint_id);
+                err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, priv_data);
                 attribute = attribute::get_next(attribute);
             }
             cluster = cluster::get_next(cluster);
@@ -123,20 +124,19 @@ static esp_err_t app_driver_attribute_set_defaults()
     return err;
 }
 
-esp_err_t app_driver_init()
+void *app_driver_light_init()
 {
-    ESP_LOGI(TAG, "Initialising driver");
-
-    /* Initialize button */
-    button_config_t button_config = button_driver_get_config();
-    button_handle_t handle = iot_button_create(&button_config);
-    iot_button_register_cb(handle, BUTTON_PRESS_DOWN, app_driver_button_toggle_cb);
-    app_reset_button_register(handle);
-
     /* Initialize led */
-    led_driver_config_t led_config = led_driver_get_config();
-    led_driver_init(&led_config);
-
-    app_driver_attribute_set_defaults();
-    return ESP_OK;
+    led_driver_config_t config = led_driver_get_config();
+    led_driver_handle_t handle = led_driver_init(&config);
+    return (void *)handle;
+}
+
+void *app_driver_switch_init()
+{
+    /* Initialize button */
+    button_config_t config = button_driver_get_config();
+    button_handle_t handle = iot_button_create(&config);
+    iot_button_register_cb(handle, BUTTON_PRESS_DOWN, app_driver_button_toggle_cb);
+    return (void *)handle;
 }

examples/light/main/app_main.cpp

@@ -17,6 +17,7 @@
 
 #include <app_priv.h>
 #include <app_qrcode.h>
+#include <app_reset.h>
 
 static const char *TAG = "app_main";
 uint16_t light_endpoint_id = 0;
@@ -59,7 +60,7 @@ static esp_err_t app_attribute_update_cb(attribute::callback_type_t type, uint16
 
     if (type == PRE_UPDATE) {
         /* Driver update */
-        err = app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, val);
+        err = app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, val, priv_data);
     }
 
     return err;
@@ -72,6 +73,11 @@ extern "C" void app_main()
     /* Initialize the ESP NVS layer */
     nvs_flash_init();
 
+    /* Initialize driver */
+    void *light_handle = app_driver_light_init();
+    void *switch_handle = app_driver_switch_init();
+    app_reset_button_register(switch_handle);
+
     /* Create a Matter node */
     node::config_t node_config;
     node_t *node = node::create(&node_config, app_attribute_update_cb, app_identify_cb);
@@ -79,7 +85,7 @@ extern "C" void app_main()
     color_temperature_light::config_t light_config;
     light_config.on_off.on_off = DEFAULT_POWER;
     light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
-    endpoint_t *endpoint = color_temperature_light::create(node, &light_config, ENDPOINT_FLAG_NONE, NULL);
+    endpoint_t *endpoint = color_temperature_light::create(node, &light_config, ENDPOINT_FLAG_NONE, light_handle);
 
     /* These node and endpoint handles can be used to create/add other endpoints and clusters. */
     if (!node || !endpoint) {
@@ -96,8 +102,8 @@ extern "C" void app_main()
     hue_saturation_config.current_saturation = DEFAULT_SATURATION;
     cluster::color_control::feature::hue_saturation::add(cluster, &hue_saturation_config);
 
-    /* Initialize driver */
-    app_driver_init();
+    /* Initialize driver defaults */
+    app_driver_attribute_set_defaults();
 
     /* Matter start */
     err = esp_matter::start(app_event_cb);

examples/light/main/app_priv.h

@@ -29,14 +29,23 @@
 #define DEFAULT_HUE 128
 #define DEFAULT_SATURATION 255
 
-/** Initialize the board and the drivers
+/** Initialize the light driver
  *
- * This initializes the selected board, which then initializes the respective drivers associated with it.
+ * This initializes the light driver associated with the selected board.
  *
- * @return ESP_OK on success.
- * @return error in case of failure.
+ * @return Handle on success.
+ * @return NULL in case of failure.
  */
-esp_err_t app_driver_init(void);
+void *app_driver_light_init();
+
+/** Initialize the switch driver
+ *
+ * This initializes the switch driver associated with the selected board.
+ *
+ * @return Handle on success.
+ * @return NULL in case of failure.
+ */
+void *app_driver_switch_init();
 
 /** Driver Update
  *
@@ -52,4 +61,13 @@ esp_err_t app_driver_init(void);
  * @return error in case of failure.
  */
 esp_err_t app_driver_attribute_update(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
-                                      esp_matter_attr_val_t *val);
+                                      esp_matter_attr_val_t *val, void *priv_data);
+
+/** Set driver defaults
+ *
+ * Set the attribute drivers to their default values from the created data model.
+ *
+ * @return ESP_OK on success.
+ * @return error in case of failure.
+ */
+esp_err_t app_driver_attribute_set_defaults();

examples/light_switch/main/app_driver.cpp

@@ -130,13 +130,13 @@ static void app_driver_button_toggle_cb(void *arg)
 }
 
 esp_err_t app_driver_attribute_update(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
-                                      esp_matter_attr_val_t *val)
+                                      esp_matter_attr_val_t *val, void *priv_data)
 {
     /* Nothing to do here */
     return ESP_OK;
 }
 
-static esp_err_t app_driver_attribute_set_defaults()
+esp_err_t app_driver_attribute_set_defaults()
 {
     /* Get the default value (current value) from esp_matter and update the app_driver */
     esp_err_t err = ESP_OK;
@@ -152,7 +152,8 @@ static esp_err_t app_driver_attribute_set_defaults()
                 uint32_t attribute_id = attribute::get_id(attribute);
                 esp_matter_attr_val_t val = esp_matter_invalid(NULL);
                 err |= attribute::get_val(attribute, &val);
-                err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+                void *priv_data = endpoint::get_priv_data(endpoint_id);
+                err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, priv_data);
                 attribute = attribute::get_next(attribute);
             }
             cluster = cluster::get_next(cluster);
@@ -162,18 +163,16 @@ static esp_err_t app_driver_attribute_set_defaults()
     return err;
 }
 
-esp_err_t app_driver_init()
+void *app_driver_switch_init()
 {
-    ESP_LOGI(TAG, "Initialising driver");
-
     /* Initialize button */
-    button_config_t button_config = button_driver_get_config();
-    button_handle_t handle = iot_button_create(&button_config);
+    button_config_t config = button_driver_get_config();
+    button_handle_t handle = iot_button_create(&config);
     iot_button_register_cb(handle, BUTTON_PRESS_DOWN, app_driver_button_toggle_cb);
-    app_reset_button_register(handle);
 
-    app_driver_attribute_set_defaults();
+    /* Other initializations */
     app_driver_register_commands();
     client::set_command_callback(app_driver_client_command_callback, NULL);
-    return ESP_OK;
+
+    return (void *)handle;
 }

examples/light_switch/main/app_main.cpp

@@ -17,6 +17,7 @@
 
 #include <app_priv.h>
 #include <app_qrcode.h>
+#include <app_reset.h>
 
 static const char *TAG = "app_main";
 uint16_t switch_endpoint_id = 0;
@@ -58,7 +59,7 @@ static esp_err_t app_attribute_update_cb(callback_type_t type, uint16_t endpoint
 
     if (type == PRE_UPDATE) {
         /* Driver update */
-        err = app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, val);
+        err = app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, val, priv_data);
     }
 
     return err;
@@ -71,12 +72,16 @@ extern "C" void app_main()
     /* Initialize the ESP NVS layer */
     nvs_flash_init();
 
+    /* Initialize driver */
+    void *switch_handle = app_driver_switch_init();
+    app_reset_button_register(switch_handle);
+
     /* Create a Matter node */
     node::config_t node_config;
     node_t *node = node::create(&node_config, app_attribute_update_cb, app_identify_cb);
 
     on_off_switch::config_t switch_config;
-    endpoint_t *endpoint = on_off_switch::create(node, &switch_config, ENDPOINT_FLAG_NONE, NULL);
+    endpoint_t *endpoint = on_off_switch::create(node, &switch_config, ENDPOINT_FLAG_NONE, switch_handle);
 
     /* These node and endpoint handles can be used to create/add other endpoints and clusters. */
     if (!node || !endpoint) {
@@ -86,9 +91,6 @@ extern "C" void app_main()
     switch_endpoint_id = endpoint::get_id(endpoint);
     ESP_LOGI(TAG, "Switch created with endpoint_id %d", switch_endpoint_id);
 
-    /* Initialize driver */
-    app_driver_init();
-
     /* Matter start */
     err = esp_matter::start(app_event_cb);
     if (err != ESP_OK) {

examples/light_switch/main/app_priv.h

@@ -11,14 +11,14 @@
 #include <esp_err.h>
 #include <esp_matter.h>
 
-/** Initialize the board and the drivers
+/** Initialize the switch driver
  *
- * This initializes the selected board, which then initializes the respective drivers associated with it.
+ * This initializes the switch driver associated with the selected board.
  *
- * @return ESP_OK on success.
- * @return error in case of failure.
+ * @return Handle on success.
+ * @return NULL in case of failure.
  */
-esp_err_t app_driver_init(void);
+void *app_driver_switch_init();
 
 /** Driver Update
  *
@@ -34,4 +34,13 @@ esp_err_t app_driver_init(void);
  * @return error in case of failure.
  */
 esp_err_t app_driver_attribute_update(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
-                                      esp_matter_attr_val_t *val);
+                                      esp_matter_attr_val_t *val, void *priv_data);
+
+/** Set driver defaults
+ *
+ * Set the attribute drivers to their default values from the created data model.
+ *
+ * @return ESP_OK on success.
+ * @return error in case of failure.
+ */
+esp_err_t app_driver_attribute_set_defaults();

examples/zap_light/main/app_driver.cpp

@@ -22,35 +22,36 @@ using namespace esp_matter;
 
 static const char *TAG = "app_driver";
 extern uint16_t light_endpoint_id;
+extern void *light_handle;
 
 /* Do any conversions/remapping for the actual value here */
-static esp_err_t app_driver_light_set_power(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_power(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
-    return led_driver_set_power(val->val.b);
+    return led_driver_set_power(handle, val->val.b);
 }
 
-static esp_err_t app_driver_light_set_brightness(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_brightness(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     int value = REMAP_TO_RANGE(val->val.u8, MATTER_BRIGHTNESS, STANDARD_BRIGHTNESS);
-    return led_driver_set_brightness(value);
+    return led_driver_set_brightness(handle, value);
 }
 
-static esp_err_t app_driver_light_set_hue(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_hue(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     int value = REMAP_TO_RANGE(val->val.u8, MATTER_HUE, STANDARD_HUE);
-    return led_driver_set_hue(value);
+    return led_driver_set_hue(handle, value);
 }
 
-static esp_err_t app_driver_light_set_saturation(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_saturation(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     int value = REMAP_TO_RANGE(val->val.u8, MATTER_SATURATION, STANDARD_SATURATION);
-    return led_driver_set_saturation(value);
+    return led_driver_set_saturation(handle, value);
 }
 
-static esp_err_t app_driver_light_set_temperature(esp_matter_attr_val_t *val)
+static esp_err_t app_driver_light_set_temperature(led_driver_handle_t handle, esp_matter_attr_val_t *val)
 {
     uint32_t value = REMAP_TO_RANGE_INVERSE(val->val.u16, STANDARD_TEMPERATURE_FACTOR);
-    return led_driver_set_temperature(value);
+    return led_driver_set_temperature(handle, value);
 }
 
 static void app_driver_button_toggle_cb(void *arg)
@@ -68,25 +69,26 @@ static void app_driver_button_toggle_cb(void *arg)
 }
 
 esp_err_t app_driver_attribute_update(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
-                                      esp_matter_attr_val_t *val)
+                                      esp_matter_attr_val_t *val, void *priv_data)
 {
     esp_err_t err = ESP_OK;
     if (endpoint_id == light_endpoint_id) {
+        led_driver_handle_t handle = (led_driver_handle_t)priv_data;
         if (cluster_id == OnOff::Id) {
             if (attribute_id == OnOff::Attributes::OnOff::Id) {
-                err = app_driver_light_set_power(val);
+                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(val);
+                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(val);
+                err = app_driver_light_set_hue(handle, val);
             } else if (attribute_id == ColorControl::Attributes::CurrentSaturation::Id) {
-                err = app_driver_light_set_saturation(val);
+                err = app_driver_light_set_saturation(handle, val);
             } else if (attribute_id == ColorControl::Attributes::ColorTemperature::Id) {
-                err = app_driver_light_set_temperature(val);
+                err = app_driver_light_set_temperature(handle, val);
             }
         }
     }
@@ -111,53 +113,52 @@ esp_err_t app_driver_attribute_set_defaults()
     attribute_id = OnOff::Attributes::OnOff::Id;
     attribute::get_val_raw(endpoint_id, cluster_id, attribute_id, &value, sizeof(uint8_t));
     val = esp_matter_bool(value);
-    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, light_handle);
 
     endpoint_id = light_endpoint_id;
     cluster_id = LevelControl::Id;
     attribute_id = LevelControl::Attributes::CurrentLevel::Id;
     attribute::get_val_raw(endpoint_id, cluster_id, attribute_id, &value, sizeof(uint8_t));
     val = esp_matter_uint8(value);
-    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, light_handle);
 
     endpoint_id = light_endpoint_id;
     cluster_id = ColorControl::Id;
     attribute_id = ColorControl::Attributes::CurrentHue::Id;
     attribute::get_val_raw(endpoint_id, cluster_id, attribute_id, &value, sizeof(uint8_t));
     val = esp_matter_uint8(value);
-    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, light_handle);
 
     endpoint_id = light_endpoint_id;
     cluster_id = ColorControl::Id;
     attribute_id = ColorControl::Attributes::CurrentSaturation::Id;
     attribute::get_val_raw(endpoint_id, cluster_id, attribute_id, &value, sizeof(uint8_t));
     val = esp_matter_uint8(value);
-    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, light_handle);
 
     endpoint_id = light_endpoint_id;
     cluster_id = ColorControl::Id;
     attribute_id = ColorControl::Attributes::ColorTemperature::Id;
     attribute::get_val_raw(endpoint_id, cluster_id, attribute_id, (uint8_t *)&value_u16, sizeof(uint16_t));
     val = esp_matter_uint16(value_u16);
-    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val);
+    err |= app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, &val, light_handle);
 
     return err;
 }
 
-esp_err_t app_driver_init()
+void *app_driver_light_init()
 {
-    ESP_LOGI(TAG, "Initialising driver");
-
-    /* Initialize button */
-    button_config_t button_config = button_driver_get_config();
-    button_handle_t handle = iot_button_create(&button_config);
-    iot_button_register_cb(handle, BUTTON_PRESS_DOWN, app_driver_button_toggle_cb);
-    app_reset_button_register(handle);
-
     /* Initialize led */
-    led_driver_config_t led_config = led_driver_get_config();
-    led_driver_init(&led_config);
-
-    /* Attribute defaults are set after esp_matter::start() from app_main() */
-    return ESP_OK;
+    led_driver_config_t config = led_driver_get_config();
+    led_driver_handle_t handle = led_driver_init(&config);
+    return (void *)handle;
+}
+
+void *app_driver_switch_init()
+{
+    /* Initialize button */
+    button_config_t config = button_driver_get_config();
+    button_handle_t handle = iot_button_create(&config);
+    iot_button_register_cb(handle, BUTTON_PRESS_DOWN, app_driver_button_toggle_cb);
+    return (void *)handle;
 }

examples/zap_light/main/app_main.cpp

@@ -16,12 +16,14 @@
 
 #include <app_priv.h>
 #include <app_qrcode.h>
+#include <app_reset.h>
 
 using namespace esp_matter;
 using namespace esp_matter::attribute;
 
 static const char *TAG = "app_main";
 uint16_t light_endpoint_id = 0;
+void *light_handle = NULL;
 
 static void app_event_cb(const ChipDeviceEvent *event, intptr_t arg)
 {
@@ -49,7 +51,7 @@ static esp_err_t app_attribute_update_cb(callback_type_t type, uint16_t endpoint
 
     if (type == PRE_UPDATE) {
         /* Driver update */
-        err = app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, val);
+        err = app_driver_attribute_update(endpoint_id, cluster_id, attribute_id, val, light_handle);
     }
 
     return err;
@@ -62,13 +64,15 @@ extern "C" void app_main()
     /* Initialize the ESP NVS layer */
     nvs_flash_init();
 
+    /* Initialize driver */
+    light_handle = app_driver_light_init();
+    void *switch_handle = app_driver_switch_init();
+    app_reset_button_register(switch_handle);
+
     /* Initialize matter callback */
     attribute::set_callback(app_attribute_update_cb);
     light_endpoint_id = 1; /* This is from zap-generated/endpoint_config.h */
 
-    /* Initialize driver */
-    app_driver_init();
-
     /* Matter start */
     err = esp_matter::start(app_event_cb);
     if (err != ESP_OK) {

examples/zap_light/main/app_priv.h

@@ -23,14 +23,23 @@
 #define MATTER_SATURATION 255
 #define MATTER_TEMPERATURE_FACTOR 1000000
 
-/** Initialize the board and the drivers
+/** Initialize the light driver
  *
- * This initializes the selected board, which then initializes the respective drivers associated with it.
+ * This initializes the light driver associated with the selected board.
  *
- * @return ESP_OK on success.
- * @return error in case of failure.
+ * @return Handle on success.
+ * @return NULL in case of failure.
  */
-esp_err_t app_driver_init(void);
+void *app_driver_light_init();
+
+/** Initialize the switch driver
+ *
+ * This initializes the switch driver associated with the selected board.
+ *
+ * @return Handle on success.
+ * @return NULL in case of failure.
+ */
+void *app_driver_switch_init();
 
 /** Driver Update
  *
@@ -46,7 +55,7 @@ esp_err_t app_driver_init(void);
  * @return error in case of failure.
  */
 esp_err_t app_driver_attribute_update(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
-                                      esp_matter_attr_val_t *val);
+                                      esp_matter_attr_val_t *val, void *priv_data);
 
 /** Set driver defaults
  *