led_strip: support for 4 components RGBW leds (SK6812) (#126)

Pac72 · suda-morris · web-flow · commit ccd598e044e9 · 2023-01-17T14:20:55.000+08:00
* Support for 4 components RGBW leds (SK6812)

Co-authored-by: suda-morris &lt;362953310@qq.com&gt;
diff --git a/led_strip/CHANGELOG.md b/led_strip/CHANGELOG.md
@@ -12,3 +12,12 @@
 - Support various RMT clock sources
 - Acquire and release the power management lock before and after each refresh
 - New driver flag: `invert_out` which can invert the led control signal by hardware
+
+## 2.2.0
+
+- Support for 4 components RGBW leds (SK6812):
+  - in led_strip_config_t new fields
+      led_pixel_format, controlling byte format (LED_PIXEL_FORMAT_GRB, LED_PIXEL_FORMAT_GRBW)
+      led_model, used to configure bit timing (LED_MODEL_WS2812, LED_MODEL_SK6812)
+  - new API led_strip_set_pixel_rgbw
+  - new interface type set_pixel_rgbw
diff --git a/led_strip/idf_component.yml b/led_strip/idf_component.yml
@@ -1,4 +1,4 @@
-version: "2.1.0"
+version: "2.2.0"
 description: Driver for Addressable LED Strip (WS2812, etc)
 url: https://github.com/espressif/idf-extra-components/tree/master/led_strip
 dependencies:
diff --git a/led_strip/include/led_strip.h b/led_strip/include/led_strip.h
@@ -29,6 +29,22 @@ extern "C" {
  */
 esp_err_t led_strip_set_pixel(led_strip_handle_t strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue);
 
+/**
+ * @brief Set RGBW for a specific pixel
+ *
+ * @param strip: LED strip
+ * @param index: index of pixel to set
+ * @param red: red part of color
+ * @param green: green part of color
+ * @param blue: blue part of color
+ * @param white: separate white component (sk6812rgbw leds)
+ *
+ * @return
+ *      - ESP_OK: RGBW color succesfully set for the pixel
+ *      - ESP_ERR_INVALID_ARG: Set RGB for a specific pixel failed because of an invalid argument
+ */
+esp_err_t led_strip_set_pixel_rgbw(led_strip_handle_t strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue, uint32_t white);
+
 /**
  * @brief Refresh memory colors to LEDs
  *
diff --git a/led_strip/include/led_strip_types.h b/led_strip/include/led_strip_types.h
@@ -11,6 +11,16 @@
 extern "C" {
 #endif
 
+typedef enum {
+    LED_PIXEL_FORMAT_GRB,
+    LED_PIXEL_FORMAT_GRBW
+} led_pixel_format_t;
+
+typedef enum {
+    LED_MODEL_WS2812,
+    LED_MODEL_SK6812
+} led_model_t;
+
 /**
  * @brief LED strip handle
  */
@@ -22,6 +32,8 @@ typedef struct led_strip_t *led_strip_handle_t;
 typedef struct {
     uint32_t strip_gpio_num; /*!< GPIO number that used by LED strip */
     uint32_t max_leds;       /*!< Maximum LEDs in a single strip */
+    led_pixel_format_t led_pixel_format;
+    led_model_t led_model;
     struct {
         uint32_t invert_out: 1; /*!< Invert output signal */
     } flags;
diff --git a/led_strip/interface/led_strip_interface.h b/led_strip/interface/led_strip_interface.h
@@ -34,6 +34,22 @@ struct led_strip_t {
      */
     esp_err_t (*set_pixel)(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue);
 
+    /**
+     * @brief Set RGBW for a specific pixel
+     *
+     * @param strip: LED strip
+     * @param index: index of pixel to set
+     * @param red: red part of color
+     * @param green: green part of color
+     * @param blue: blue part of color
+     * @param white: separate white component (sk6812rgbw leds)
+     *
+     * @return
+     *      - ESP_OK: RGBW color succesfully set for the pixel
+     *      - ESP_ERR_INVALID_ARG: Set RGB for a specific pixel failed because of an invalid argument
+     */
+    esp_err_t (*set_pixel_rgbw)(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue, uint32_t white);
+
     /**
      * @brief Refresh memory colors to LEDs
      *
diff --git a/led_strip/src/led_strip_api.c b/led_strip/src/led_strip_api.c
@@ -16,6 +16,12 @@ esp_err_t led_strip_set_pixel(led_strip_handle_t strip, uint32_t index, uint32_t
     return strip->set_pixel(strip, index, red, green, blue);
 }
 
+esp_err_t led_strip_set_pixel_rgbw(led_strip_handle_t strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue, uint32_t white)
+{
+    ESP_RETURN_ON_FALSE(strip, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return strip->set_pixel_rgbw(strip, index, red, green, blue, white);
+}
+
 esp_err_t led_strip_refresh(led_strip_handle_t strip)
 {
     ESP_RETURN_ON_FALSE(strip, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
diff --git a/led_strip/src/led_strip_rmt_dev.c b/led_strip/src/led_strip_rmt_dev.c
@@ -22,18 +22,36 @@ typedef struct {
     rmt_channel_handle_t rmt_chan;
     rmt_encoder_handle_t strip_encoder;
     uint32_t strip_len;
+    uint8_t bytes_per_pixel;
     uint8_t pixel_buf[];
 } led_strip_rmt_obj;
 
 static esp_err_t led_strip_rmt_set_pixel(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue)
 {
     led_strip_rmt_obj *rmt_strip = __containerof(strip, led_strip_rmt_obj, base);
     ESP_RETURN_ON_FALSE(index < rmt_strip->strip_len, ESP_ERR_INVALID_ARG, TAG, "index out of maximum number of LEDs");
-    uint32_t start = index * 3;
+    uint32_t start = index * rmt_strip->bytes_per_pixel;
     // In thr order of GRB, as LED strip like WS2812 sends out pixels in this order
     rmt_strip->pixel_buf[start + 0] = green & 0xFF;
     rmt_strip->pixel_buf[start + 1] = red & 0xFF;
     rmt_strip->pixel_buf[start + 2] = blue & 0xFF;
+    if (rmt_strip->bytes_per_pixel > 3) {
+        rmt_strip->pixel_buf[start + 3] = 0;
+    }
+    return ESP_OK;
+}
+
+static esp_err_t led_strip_rmt_set_pixel_rgbw(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue, uint32_t white)
+{
+    led_strip_rmt_obj *rmt_strip = __containerof(strip, led_strip_rmt_obj, base);
+    ESP_RETURN_ON_FALSE(index < rmt_strip->strip_len, ESP_ERR_INVALID_ARG, TAG, "index out of maximum number of LEDs");
+    ESP_RETURN_ON_FALSE(rmt_strip->bytes_per_pixel == 4, ESP_ERR_INVALID_ARG, TAG, "wrong LED pixel format, expected 4 bytes per pixel");
+    uint8_t *buf_start = rmt_strip->pixel_buf + index * 4;
+    // SK6812 component order is GRBW
+    *buf_start = green & 0xFF;
+    *++buf_start = red & 0xFF;
+    *++buf_start = blue & 0xFF;
+    *++buf_start = white & 0xFF;
     return ESP_OK;
 }
 
@@ -46,7 +64,7 @@ static esp_err_t led_strip_rmt_refresh(led_strip_t *strip)
 
     ESP_RETURN_ON_ERROR(rmt_enable(rmt_strip->rmt_chan), TAG, "enable RMT channel failed");
     ESP_RETURN_ON_ERROR(rmt_transmit(rmt_strip->rmt_chan, rmt_strip->strip_encoder, rmt_strip->pixel_buf,
-                                     rmt_strip->strip_len * 3, &tx_conf), TAG, "transmit pixels by RMT failed");
+                                     rmt_strip->strip_len * rmt_strip->bytes_per_pixel, &tx_conf), TAG, "transmit pixels by RMT failed");
     ESP_RETURN_ON_ERROR(rmt_tx_wait_all_done(rmt_strip->rmt_chan, -1), TAG, "flush RMT channel failed");
     ESP_RETURN_ON_ERROR(rmt_disable(rmt_strip->rmt_chan), TAG, "disable RMT channel failed");
     return ESP_OK;
@@ -56,7 +74,7 @@ static esp_err_t led_strip_rmt_clear(led_strip_t *strip)
 {
     led_strip_rmt_obj *rmt_strip = __containerof(strip, led_strip_rmt_obj, base);
     // Write zero to turn off all leds
-    memset(rmt_strip->pixel_buf, 0, rmt_strip->strip_len * 3);
+    memset(rmt_strip->pixel_buf, 0, rmt_strip->strip_len * rmt_strip->bytes_per_pixel);
     return led_strip_rmt_refresh(strip);
 }
 
@@ -74,7 +92,14 @@ esp_err_t led_strip_new_rmt_device(const led_strip_config_t *led_config, const l
     led_strip_rmt_obj *rmt_strip = NULL;
     esp_err_t ret = ESP_OK;
     ESP_GOTO_ON_FALSE(led_config && rmt_config && ret_strip, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
-    rmt_strip = calloc(1, sizeof(led_strip_rmt_obj) + led_config->max_leds * 3);
+    ESP_GOTO_ON_FALSE(led_config->led_pixel_format <= LED_PIXEL_FORMAT_GRBW, ESP_ERR_INVALID_ARG, err, TAG, "invalid led_pixel_format");
+    uint8_t bytes_per_pixel;
+    if (led_config->led_pixel_format == LED_PIXEL_FORMAT_GRBW) {
+        bytes_per_pixel = 4;
+    } else {
+        bytes_per_pixel = 3;
+    }
+    rmt_strip = calloc(1, sizeof(led_strip_rmt_obj) + led_config->max_leds * bytes_per_pixel);
     ESP_GOTO_ON_FALSE(rmt_strip, ESP_ERR_NO_MEM, err, TAG, "no mem for rmt strip");
     uint32_t resolution = rmt_config->resolution_hz ? rmt_config->resolution_hz : LED_STRIP_RMT_DEFAULT_RESOLUTION;
 
@@ -96,12 +121,15 @@ esp_err_t led_strip_new_rmt_device(const led_strip_config_t *led_config, const l
 
     led_strip_encoder_config_t strip_encoder_conf = {
         .resolution = resolution,
+        .led_model = led_config->led_model
     };
     ESP_GOTO_ON_ERROR(rmt_new_led_strip_encoder(&strip_encoder_conf, &rmt_strip->strip_encoder), err, TAG, "create LED strip encoder failed");
 
 
+    rmt_strip->bytes_per_pixel = bytes_per_pixel;
     rmt_strip->strip_len = led_config->max_leds;
     rmt_strip->base.set_pixel = led_strip_rmt_set_pixel;
+    rmt_strip->base.set_pixel_rgbw = led_strip_rmt_set_pixel_rgbw;
     rmt_strip->base.refresh = led_strip_rmt_refresh;
     rmt_strip->base.clear = led_strip_rmt_clear;
     rmt_strip->base.del = led_strip_rmt_del;
diff --git a/led_strip/src/led_strip_rmt_encoder.c b/led_strip/src/led_strip_rmt_encoder.c
@@ -81,22 +81,41 @@ esp_err_t rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config, rm
     led_encoder->base.encode = rmt_encode_led_strip;
     led_encoder->base.del = rmt_del_led_strip_encoder;
     led_encoder->base.reset = rmt_led_strip_encoder_reset;
-    // different led strip might have its own timing requirements, following parameter is for WS2812
-    rmt_bytes_encoder_config_t bytes_encoder_config = {
-        .bit0 = {
-            .level0 = 1,
-            .duration0 = 0.3 * config->resolution / 1000000, // T0H=0.3us
-            .level1 = 0,
-            .duration1 = 0.9 * config->resolution / 1000000, // T0L=0.9us
-        },
-        .bit1 = {
-            .level0 = 1,
-            .duration0 = 0.9 * config->resolution / 1000000, // T1H=0.9us
-            .level1 = 0,
-            .duration1 = 0.3 * config->resolution / 1000000, // T1L=0.3us
-        },
-        .flags.msb_first = 1 // WS2812 transfer bit order: G7...G0R7...R0B7...B0
-    };
+    rmt_bytes_encoder_config_t bytes_encoder_config;
+    if (config->led_model == LED_MODEL_SK6812) {
+        bytes_encoder_config = (rmt_bytes_encoder_config_t) {
+            .bit0 = {
+                .level0 = 1,
+                .duration0 = 0.3 * config->resolution / 1000000, // T0H=0.3us
+                .level1 = 0,
+                .duration1 = 0.9 * config->resolution / 1000000, // T0L=0.9us
+            },
+            .bit1 = {
+                .level0 = 1,
+                .duration0 = 0.6 * config->resolution / 1000000, // T1H=0.6us
+                .level1 = 0,
+                .duration1 = 0.6 * config->resolution / 1000000, // T1L=0.6us
+            },
+            .flags.msb_first = 1 // SK6812 transfer bit order: G7...G0R7...R0B7...B0W7...W0
+        };
+    } else {
+        // different led strip might have its own timing requirements, following parameter is for WS2812
+        bytes_encoder_config = (rmt_bytes_encoder_config_t) {
+            .bit0 = {
+                .level0 = 1,
+                .duration0 = 0.3 * config->resolution / 1000000, // T0H=0.3us
+                .level1 = 0,
+                .duration1 = 0.9 * config->resolution / 1000000, // T0L=0.9us
+            },
+            .bit1 = {
+                .level0 = 1,
+                .duration0 = 0.9 * config->resolution / 1000000, // T1H=0.9us
+                .level1 = 0,
+                .duration1 = 0.3 * config->resolution / 1000000, // T1L=0.3us
+            },
+            .flags.msb_first = 1 // WS2812 transfer bit order: G7...G0R7...R0B7...B0
+        };
+    }
     ESP_GOTO_ON_ERROR(rmt_new_bytes_encoder(&bytes_encoder_config, &led_encoder->bytes_encoder), err, TAG, "create bytes encoder failed");
     rmt_copy_encoder_config_t copy_encoder_config = {};
     ESP_GOTO_ON_ERROR(rmt_new_copy_encoder(&copy_encoder_config, &led_encoder->copy_encoder), err, TAG, "create copy encoder failed");
diff --git a/led_strip/src/led_strip_rmt_encoder.h b/led_strip/src/led_strip_rmt_encoder.h
@@ -7,6 +7,7 @@
 
 #include <stdint.h>
 #include "driver/rmt_encoder.h"
+#include "led_strip_types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -17,6 +18,7 @@ extern "C" {
  */
 typedef struct {
     uint32_t resolution; /*!< Encoder resolution, in Hz */
+    led_model_t led_model;
 } led_strip_encoder_config_t;
 
 /**

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-version: "2.1.0"`
	`1`	`+version: "2.2.0"`
`2`	`2`	`description: Driver for Addressable LED Strip (WS2812, etc)`
`3`	`3`	`url: https://github.com/espressif/idf-extra-components/tree/master/led_strip`
`4`	`4`	`dependencies:`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,12 @@ esp_err_t led_strip_set_pixel(led_strip_handle_t strip, uint32_t index, uint32_t`
`16`	`16`	`return strip->set_pixel(strip, index, red, green, blue);`
`17`	`17`	`}`
`18`	`18`
	`19`	`+esp_err_t led_strip_set_pixel_rgbw(led_strip_handle_t strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue, uint32_t white)`
	`20`	`+{`
	`21`	`+ ESP_RETURN_ON_FALSE(strip, ESP_ERR_INVALID_ARG, TAG, "invalid argument");`
	`22`	`+ return strip->set_pixel_rgbw(strip, index, red, green, blue, white);`
	`23`	`+}`
	`24`	`+`
`19`	`25`	`esp_err_t led_strip_refresh(led_strip_handle_t strip)`
`20`	`26`	`{`
`21`	`27`	`ESP_RETURN_ON_FALSE(strip, ESP_ERR_INVALID_ARG, TAG, "invalid argument");`