device_hal: Restructuring to make the usage flexible.

button_driver: Add support for gpio and adc from esp-iot-solution.
led_driver: Renamed light_driver to led_driver.
app_driver: Using this restructured device_hal.
app_driver: Added toggle based on button_driver.

device_hal/led_driver/CMakeLists.txt

@@ -0,0 +1,12 @@
+include($ENV{ESP_MATTER_DEVICE_PATH}/esp_matter_device.cmake)
+
+set(led_requires driver)
+if ("${led_type}" STREQUAL "ws2812")
+    list(APPEND led_requires led_strip)
+elseif ("${led_type}" STREQUAL "vled")
+    list(APPEND led_requires tft spidriver)
+endif()
+
+idf_component_register(SRC_DIRS ${led_type} utils
+                    INCLUDE_DIRS include
+                    PRIV_REQUIRES ${led_requires})

device_hal/led_driver/gpio/led_driver.c

@@ -0,0 +1,126 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#include <driver/ledc.h>
+#include <esp_log.h>
+#include <hal/ledc_types.h>
+
+#include <led_driver.h>
+
+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)
+{
+    ESP_LOGI(TAG, "Initializing light driver");
+    esp_err_t err = ESP_OK;
+
+    ledc_timer_config_t ledc_timer = {
+        .speed_mode = LEDC_LOW_SPEED_MODE, // timer mode
+        .duty_resolution = LEDC_TIMER_8_BIT, // resolution of PWM duty
+        .timer_num = LEDC_TIMER_1, // timer index
+        .freq_hz = 5000, // frequency of PWM signal
+        .clk_cfg = LEDC_AUTO_CLK, // Auto select the source clock
+    };
+    err = ledc_timer_config(&ledc_timer);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "led_timerc_config failed");
+        return err;
+    }
+
+    ledc_channel_config_t ledc_channel = {
+        .gpio_num = config->gpio,
+        .speed_mode = LEDC_LOW_SPEED_MODE,
+        .channel = config->channel,
+        .intr_type = LEDC_INTR_DISABLE,
+        .timer_sel = LEDC_TIMER_1,
+        .duty = 0,
+        .hpoint = 0,
+    };
+    err = ledc_channel_config(&ledc_channel);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ledc_channel_config failed");
+    }
+
+    return err;
+}
+
+esp_err_t led_driver_set_power(bool power)
+{
+    current_power = power;
+    return led_driver_set_brightness(current_brightness);
+}
+
+esp_err_t led_driver_set_brightness(uint8_t brightness)
+{
+    esp_err_t err;
+
+    if (brightness != 0) {
+        current_brightness = brightness;
+    }
+    if (!current_power) {
+        brightness = 0;
+    }
+
+    err = ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, brightness);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ledc_set_duty failed");
+    }
+
+    err = ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ledc_update_duty failed");
+    }
+    return err;
+}
+
+esp_err_t led_driver_set_hue(uint16_t hue)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t led_driver_set_saturation(uint8_t saturation)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t led_driver_set_temperature(uint32_t temperature)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+bool led_driver_get_power()
+{
+    return current_power;
+}
+
+uint8_t led_driver_get_brightness()
+{
+    return current_brightness;
+}
+
+uint16_t led_driver_get_hue()
+{
+    return 0;
+}
+
+uint8_t led_driver_get_saturation()
+{
+    return 0;
+}
+
+uint32_t led_driver_get_temperature()
+{
+    return 0;
+}

device_hal/led_driver/hollow/led_driver.c

@@ -0,0 +1,95 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#include <color_format.h>
+#include <esp_log.h>
+#include <led_driver.h>
+
+static const char *TAG = "led_driver_hollow";
+static bool current_power = false;
+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)
+{
+    ESP_LOGI(TAG, "Initializing light driver");
+    /* Initialize the driver here */
+
+    return ESP_OK;
+}
+
+esp_err_t led_driver_set_power(bool power)
+{
+    ESP_LOGI(TAG, "Setting power to: %d", power);
+    /* Set the power state here */
+
+    return ESP_OK;
+}
+
+esp_err_t led_driver_set_brightness(uint8_t brightness)
+{
+    ESP_LOGI(TAG, "Setting brightness to: %d", brightness);
+    /* Set the brightness level here */
+
+    return ESP_OK;
+}
+
+esp_err_t led_driver_set_hue(uint16_t hue)
+{
+    ESP_LOGI(TAG, "Setting hue to: %d", hue);
+    /* Set the color hue here */
+
+    return ESP_OK;
+}
+
+esp_err_t led_driver_set_saturation(uint8_t saturation)
+{
+    ESP_LOGI(TAG, "Setting saturation to: %d", saturation);
+    /* Set the color saturation here */
+
+    return ESP_OK;
+}
+
+esp_err_t led_driver_set_temperature(uint32_t temperature)
+{
+    ESP_LOGI(TAG, "Setting temperature to: %d", temperature);
+    /* Set the color temp here*/
+
+    return ESP_OK;
+}
+
+bool led_driver_get_power()
+{
+    return current_power;
+}
+
+uint8_t led_driver_get_brightness()
+{
+    return current_brightness;
+}
+
+uint16_t led_driver_get_hue()
+{
+    return current_HS.hue;
+}
+
+uint8_t led_driver_get_saturation()
+{
+    return current_HS.saturation;
+}
+
+uint32_t led_driver_get_temperature()
+{
+    return current_temperature;
+}

device_hal/led_driver/include/color_format.h

@@ -0,0 +1,38 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#pragma once
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    uint16_t hue;
+    uint8_t saturation;
+} HS_color_t;
+
+typedef struct {
+    uint8_t red;
+    uint8_t green;
+    uint8_t blue;
+} RGB_color_t;
+
+void temp_to_hs(uint32_t temperature, HS_color_t *HS);
+
+void hsv_to_rgb(HS_color_t HS, uint8_t brightness, RGB_color_t *RGB);
+
+#ifdef __cplusplus
+}
+#endif

device_hal/led_driver/include/led_driver.h

@@ -0,0 +1,43 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#pragma once
+#include <esp_err.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int gpio;
+    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);
+
+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);
+
+#ifdef __cplusplus
+}
+#endif

device_hal/led_driver/utils/color_format.c

@@ -0,0 +1,88 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#include <color_format.h>
+
+void hsv_to_rgb(HS_color_t HS, uint8_t brightness, RGB_color_t *RGB)
+{
+    uint16_t sector = HS.hue / 60;
+    uint16_t rgb_max = brightness;
+    uint16_t rgb_min = rgb_max * (100 - HS.saturation) / 100;
+    uint16_t offset = HS.hue % 60;
+    uint16_t rgb_adj = (rgb_max - rgb_min) * offset / 60;
+
+    switch (sector) {
+    case 0:
+        RGB->red = rgb_max;
+        RGB->green = rgb_min + rgb_adj;
+        RGB->blue = rgb_min;
+        break;
+    case 1:
+        RGB->red = rgb_max - rgb_adj;
+        RGB->green = rgb_max;
+        RGB->blue = rgb_min;
+        break;
+    case 2:
+        RGB->red = rgb_min;
+        RGB->green = rgb_max;
+        RGB->blue = rgb_min + rgb_adj;
+        break;
+    case 3:
+        RGB->red = rgb_min;
+        RGB->green = rgb_max - rgb_adj;
+        RGB->blue = rgb_max;
+        break;
+    case 4:
+        RGB->red = rgb_min + rgb_adj;
+        RGB->green = rgb_min;
+        RGB->blue = rgb_max;
+        break;
+    default:
+        RGB->red = rgb_max;
+        RGB->green = rgb_min;
+        RGB->blue = rgb_max - rgb_adj;
+        break;
+    }
+}
+
+// A Table from color temperature to hue and saturation.
+// hue = temp_table[(temp - 600) / 100].hue
+// saturation= temp_table[(temp - 600) / 100].saturation
+// 600<= temp <= 10000
+const HS_color_t temp_table[] = {
+    {4, 100},  {8, 100},  {11, 100}, {14, 100}, {16, 100}, {18, 100}, {20, 100}, {22, 100}, {24, 100}, {25, 100},
+    {27, 100}, {28, 100}, {30, 100}, {31, 100}, {31, 95},  {30, 89},  {30, 85},  {29, 80},  {29, 76},  {29, 73},
+    {29, 69},  {28, 66},  {28, 63},  {28, 60},  {28, 57},  {28, 54},  {28, 52},  {27, 49},  {27, 47},  {27, 45},
+    {27, 43},  {27, 41},  {27, 39},  {27, 37},  {27, 35},  {27, 33},  {27, 31},  {27, 30},  {27, 28},  {27, 26},
+    {27, 25},  {27, 23},  {27, 22},  {27, 21},  {27, 19},  {27, 18},  {27, 17},  {27, 15},  {28, 14},  {28, 13},
+    {28, 12},  {29, 10},  {29, 9},   {30, 8},   {31, 7},   {32, 6},   {34, 5},   {36, 4},   {41, 3},   {49, 2},
+    {0, 0},    {294, 2},  {265, 3},  {251, 4},  {242, 5},  {237, 6},  {233, 7},  {231, 8},  {229, 9},  {228, 10},
+    {227, 11}, {226, 11}, {226, 12}, {225, 13}, {225, 13}, {224, 14}, {224, 14}, {224, 15}, {224, 15}, {223, 16},
+    {223, 16}, {223, 17}, {223, 17}, {223, 17}, {222, 18}, {222, 18}, {222, 19}, {222, 19}, {222, 19}, {222, 19},
+    {222, 20}, {222, 20}, {222, 20}, {222, 21}, {222, 21}};
+
+void temp_to_hs(uint32_t temperature, HS_color_t *HS)
+{
+    if (temperature < 600) {
+        HS->hue = 0;
+        HS->saturation = 100;
+        return;
+    }
+    if (temperature > 10000) {
+        HS->hue = 222;
+        HS->saturation = 21 + (temperature - 10000) * 41 / 990000;
+        return;
+    }
+    HS->hue = temp_table[(temperature - 600) / 100].hue;
+    HS->saturation = temp_table[(temperature - 600) / 100].saturation;
+}

device_hal/led_driver/vled/led_driver.c

@@ -0,0 +1,212 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#include <driver/ledc.h>
+#include <esp_log.h>
+#include <esp_system.h>
+#include <string.h>
+#include <tft.h>
+#include <tftspi.h>
+
+#include <color_format.h>
+#include <led_driver.h>
+
+#define TFT_SPI_CLOCK_INIT_HZ 8000000
+#define LEDC_PWM_HZ 1000
+#define BRIGHTNESS_MAX 255
+
+static const char *TAG = "led_driver_vled";
+static bool current_power = false;
+static uint8_t current_brightness = 0;
+static HS_color_t current_HS = {0, 0};
+static uint32_t current_temperature = 6600;
+static RGB_color_t mRGB;
+static uint16_t DisplayHeight;
+static uint16_t DisplayWidth;
+static int led_driver_channel = -1;
+
+static void SetupBrightnessControl(led_driver_config_t *config)
+{
+    ledc_timer_config_t ledc_timer;
+    memset(&ledc_timer, 0, sizeof(ledc_timer));
+    led_driver_channel = config->channel;
+
+    ledc_timer.duty_resolution = LEDC_TIMER_8_BIT; // resolution of PWM duty
+    ledc_timer.freq_hz = LEDC_PWM_HZ; // frequency of PWM signal
+    ledc_timer.speed_mode = LEDC_HIGH_SPEED_MODE; // timer mode
+    ledc_timer.timer_num = LEDC_TIMER_0; // timer index
+    ledc_timer_config(&ledc_timer);
+    ledc_timer_set(LEDC_HIGH_SPEED_MODE, LEDC_TIMER_0, LEDC_PWM_HZ, LEDC_TIMER_8_BIT, LEDC_REF_TICK);
+
+    ledc_channel_config_t ledc_channel;
+    memset(&ledc_channel, 0, sizeof(ledc_channel));
+    ledc_channel.channel = led_driver_channel;
+    ledc_channel.duty = BRIGHTNESS_MAX;
+    ledc_channel.gpio_num = config->gpio;
+    ledc_channel.speed_mode = LEDC_HIGH_SPEED_MODE;
+    ledc_channel.timer_sel = LEDC_TIMER_0;
+    ledc_channel_config(&ledc_channel);
+}
+
+static void SetDisplayBrightness(uint8_t brightness)
+{
+    if (ledc_set_duty(LEDC_HIGH_SPEED_MODE, led_driver_channel, brightness) ||
+        ledc_update_duty(LEDC_HIGH_SPEED_MODE, led_driver_channel)) {
+        ESP_LOGE(TAG, "Failed to set display brightness...");
+    }
+}
+
+static esp_err_t InitDisplay()
+{
+    esp_err_t err;
+    spi_lobo_device_handle_t spi;
+    spi_lobo_bus_config_t buscfg;
+    memset((void *)&buscfg, 0, sizeof(buscfg));
+    buscfg.miso_io_num = PIN_NUM_MISO; // set SPI MISO pin
+    buscfg.mosi_io_num = PIN_NUM_MOSI; // set SPI MOSI pin
+    buscfg.sclk_io_num = PIN_NUM_CLK; // set SPI CLK pin
+    buscfg.quadwp_io_num = -1;
+    buscfg.quadhd_io_num = -1;
+
+    spi_lobo_device_interface_config_t devcfg;
+    memset((void *)&devcfg, 0, sizeof(devcfg));
+    devcfg.clock_speed_hz = TFT_SPI_CLOCK_INIT_HZ;
+    devcfg.mode = 0; // SPI mode 0
+    devcfg.spics_io_num = -1; // we will use external CS pin
+    devcfg.spics_ext_io_num = PIN_NUM_CS; // external CS pi
+    devcfg.flags = LB_SPI_DEVICE_HALFDUPLEX; // ALWAYS SET  to HALF DUPLEX MODE!! for display spi
+    tft_max_rdclock = TFT_SPI_CLOCK_INIT_HZ;
+
+    // Initialize all pins used by display driver.
+    TFT_PinsInit();
+    // Initialize SPI bus and add a device for the display.
+    err = spi_lobo_bus_add_device(TFT_HSPI_HOST, &buscfg, &devcfg, &spi);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    // Configure the display to use the new SPI device.
+    tft_disp_spi = spi;
+    err = spi_lobo_device_select(spi, 1);
+    if (err != ESP_OK) {
+        return err;
+    }
+    err = spi_lobo_device_deselect(spi);
+    if (err != ESP_OK) {
+        return err;
+    }
+    // Initialize the display driver.
+    TFT_display_init();
+    // Detect maximum read speed and set it.
+    tft_max_rdclock = find_rd_speed();
+    spi_lobo_set_speed(spi, DEFAULT_SPI_CLOCK);
+
+    TFT_setGammaCurve(0);
+    TFT_setRotation(LANDSCAPE);
+    TFT_resetclipwin();
+
+    DisplayWidth = (uint16_t)(1 + tft_dispWin.x2 - tft_dispWin.x1);
+    DisplayHeight = (uint16_t)(1 + tft_dispWin.y2 - tft_dispWin.y1);
+    ESP_LOGI(TAG, "Display initialized (height %u, width %u)", DisplayHeight, DisplayWidth);
+
+    TFT_invertDisplay(INVERT_OFF);
+
+    return ESP_OK;
+}
+
+esp_err_t led_driver_init(led_driver_config_t *config)
+{
+    ESP_LOGI(TAG, "Initializing led driver");
+    esp_err_t err = ESP_OK;
+    err = InitDisplay();
+    if (err != ESP_OK) {
+        return err;
+    }
+    SetupBrightnessControl(config);
+    SetDisplayBrightness(BRIGHTNESS_MAX);
+    return err;
+}
+
+esp_err_t led_driver_set_power(bool power)
+{
+    current_power = power;
+    return led_driver_set_brightness(current_brightness);
+}
+esp_err_t led_driver_set_RGB()
+{
+    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)
+{
+    if (brightness != 0) {
+        current_brightness = brightness;
+    }
+    if (!current_power) {
+        brightness = 0;
+    }
+    hsv_to_rgb(current_HS, brightness, &mRGB);
+    return led_driver_set_RGB();
+}
+
+esp_err_t led_driver_set_hue(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();
+}
+
+esp_err_t led_driver_set_saturation(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();
+}
+
+esp_err_t led_driver_set_temperature(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();
+}
+
+bool led_driver_get_power()
+{
+    return current_power;
+}
+
+uint8_t led_driver_get_brightness()
+{
+    return current_brightness;
+}
+
+uint16_t led_driver_get_hue()
+{
+    return current_HS.hue;
+}
+
+uint8_t led_driver_get_saturation()
+{
+    return current_HS.saturation;
+}
+
+uint32_t led_driver_get_temperature()
+{
+    return current_temperature;
+}

device_hal/led_driver/ws2812/led_driver.c

@@ -0,0 +1,140 @@
+// Copyright 2021 Espressif Systems (Shanghai) CO LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+#include <color_format.h>
+#include <driver/rmt.h>
+#include <esp_log.h>
+#include <led_strip.h>
+#include <led_driver.h>
+
+static const char *TAG = "led_driver_ws2812";
+static bool current_power = false;
+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)
+{
+    ESP_LOGI(TAG, "Initializing light driver");
+    esp_err_t err = ESP_OK;
+
+    rmt_config_t rmt_cfg = RMT_DEFAULT_CONFIG_TX(config->gpio, config->channel);
+    rmt_cfg.clk_div = 2;
+    err = rmt_config(&rmt_cfg);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "rmt_cfg failed");
+    }
+    err = rmt_driver_install(rmt_cfg.channel, 0, 0);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "rmt_driver_install failed");
+    }
+
+    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);
+    if (!strip) {
+        ESP_LOGE(TAG, "W2812 driver install failed");
+        err = ESP_FAIL;
+    }
+    return err;
+}
+
+esp_err_t led_driver_set_power(bool power)
+{
+    current_power = power;
+    return led_driver_set_brightness(current_brightness);
+}
+
+esp_err_t led_driver_set_RGB()
+{
+    esp_err_t err = ESP_OK;
+    if (!strip) {
+        ESP_LOGE(TAG, "can't find w2812 led_strip handle");
+        err = ESP_FAIL;
+    } else {
+        err = strip->set_pixel(strip, 0, mRGB.red, mRGB.green, mRGB.blue);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "strip_set_pixel failed");
+            return err;
+        }
+        ESP_LOGI(TAG, "led set r:%d, g:%d, b:%d", mRGB.red, mRGB.green, mRGB.blue);
+        err = strip->refresh(strip, 100);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "strip_refresh failed");
+        }
+    }
+    return err;
+}
+
+esp_err_t led_driver_set_brightness(uint8_t brightness)
+{
+    if (brightness != 0) {
+        current_brightness = brightness;
+    }
+    if (!current_power) {
+        brightness = 0;
+    }
+    hsv_to_rgb(current_HS, brightness, &mRGB);
+    return led_driver_set_RGB();
+}
+
+esp_err_t led_driver_set_hue(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();
+}
+
+esp_err_t led_driver_set_saturation(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();
+}
+
+esp_err_t led_driver_set_temperature(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();
+}
+
+bool led_driver_get_power()
+{
+    return current_power;
+}
+
+uint8_t led_driver_get_brightness()
+{
+    return current_brightness;
+}
+
+uint16_t led_driver_get_hue()
+{
+    return current_HS.hue;
+}
+
+uint8_t led_driver_get_saturation()
+{
+    return current_HS.saturation;
+}
+
+uint32_t led_driver_get_temperature()
+{
+    return current_temp;
+}