Add WS2812 driver library and C++ LED strip example
Move the LED strip example to C++ and split the driver into a WS2812 class (ws2812.h/.cpp). The class takes the GPIO and LED count in its constructor and provides set(), fill(), write(), setBrightness() and a static hsv2rgb(). The RMT encoder is now internal to ws2812.cpp. Also adds a top-level Makefile wrapping idf.py for Linux, macOS and Windows, and a .gitignore for build output. Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
0c80638647
commit
d6cf56f105
9 files changed
+2626
No files matched your search
@@ -0,0 +1,237 @@
|
||||
/*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include "ws2812.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "esp_check.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
static const char *TAG = "ws2812";
|
||||
|
||||
/* ---- RMT encoder: turns RGB bytes into WS2812 waveform symbols ---- */
|
||||
|
||||
typedef struct {
|
||||
rmt_encoder_t base;
|
||||
rmt_encoder_t *bytes_encoder;
|
||||
rmt_encoder_t *copy_encoder;
|
||||
int state;
|
||||
rmt_symbol_word_t reset_code;
|
||||
} rmt_ws2812_encoder_t;
|
||||
|
||||
RMT_ENCODER_FUNC_ATTR
|
||||
static size_t rmt_encode_ws2812(rmt_encoder_t *encoder, rmt_channel_handle_t channel, const void *primary_data, size_t data_size, rmt_encode_state_t *ret_state)
|
||||
{
|
||||
rmt_ws2812_encoder_t *led_encoder = __containerof(encoder, rmt_ws2812_encoder_t, base);
|
||||
rmt_encoder_handle_t bytes_encoder = led_encoder->bytes_encoder;
|
||||
rmt_encoder_handle_t copy_encoder = led_encoder->copy_encoder;
|
||||
rmt_encode_state_t session_state = RMT_ENCODING_RESET;
|
||||
rmt_encode_state_t state = RMT_ENCODING_RESET;
|
||||
size_t encoded_symbols = 0;
|
||||
switch (led_encoder->state) {
|
||||
case 0: // send RGB data
|
||||
encoded_symbols += bytes_encoder->encode(bytes_encoder, channel, primary_data, data_size, &session_state);
|
||||
if (session_state & RMT_ENCODING_COMPLETE) {
|
||||
led_encoder->state = 1; // switch to next state when current encoding session finished
|
||||
}
|
||||
if (session_state & RMT_ENCODING_MEM_FULL) {
|
||||
state = static_cast<rmt_encode_state_t>(state | RMT_ENCODING_MEM_FULL);
|
||||
goto out; // yield if there's no free space for encoding artifacts
|
||||
}
|
||||
// fall-through
|
||||
case 1: // send reset code
|
||||
encoded_symbols += copy_encoder->encode(copy_encoder, channel, &led_encoder->reset_code,
|
||||
sizeof(led_encoder->reset_code), &session_state);
|
||||
if (session_state & RMT_ENCODING_COMPLETE) {
|
||||
led_encoder->state = RMT_ENCODING_RESET; // back to the initial encoding session
|
||||
state = static_cast<rmt_encode_state_t>(state | RMT_ENCODING_COMPLETE);
|
||||
}
|
||||
if (session_state & RMT_ENCODING_MEM_FULL) {
|
||||
state = static_cast<rmt_encode_state_t>(state | RMT_ENCODING_MEM_FULL);
|
||||
goto out; // yield if there's no free space for encoding artifacts
|
||||
}
|
||||
}
|
||||
out:
|
||||
*ret_state = state;
|
||||
return encoded_symbols;
|
||||
}
|
||||
|
||||
static esp_err_t rmt_del_ws2812_encoder(rmt_encoder_t *encoder)
|
||||
{
|
||||
rmt_ws2812_encoder_t *led_encoder = __containerof(encoder, rmt_ws2812_encoder_t, base);
|
||||
rmt_del_encoder(led_encoder->bytes_encoder);
|
||||
rmt_del_encoder(led_encoder->copy_encoder);
|
||||
free(led_encoder);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
RMT_ENCODER_FUNC_ATTR
|
||||
static esp_err_t rmt_ws2812_encoder_reset(rmt_encoder_t *encoder)
|
||||
{
|
||||
rmt_ws2812_encoder_t *led_encoder = __containerof(encoder, rmt_ws2812_encoder_t, base);
|
||||
rmt_encoder_reset(led_encoder->bytes_encoder);
|
||||
rmt_encoder_reset(led_encoder->copy_encoder);
|
||||
led_encoder->state = RMT_ENCODING_RESET;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t new_ws2812_encoder(uint32_t resolution, rmt_encoder_handle_t *ret_encoder)
|
||||
{
|
||||
// Declared up front: the error path jumps forward to `err`, which C++ forbids
|
||||
// across initialised declarations.
|
||||
esp_err_t ret = ESP_OK;
|
||||
rmt_ws2812_encoder_t *led_encoder = NULL;
|
||||
rmt_bytes_encoder_config_t bytes_encoder_config = {};
|
||||
rmt_copy_encoder_config_t copy_encoder_config = {};
|
||||
uint32_t reset_ticks = 0;
|
||||
|
||||
ESP_GOTO_ON_FALSE(ret_encoder, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
|
||||
led_encoder = static_cast<rmt_ws2812_encoder_t *>(rmt_alloc_encoder_mem(sizeof(rmt_ws2812_encoder_t)));
|
||||
ESP_GOTO_ON_FALSE(led_encoder, ESP_ERR_NO_MEM, err, TAG, "no mem for ws2812 encoder");
|
||||
led_encoder->base.encode = rmt_encode_ws2812;
|
||||
led_encoder->base.del = rmt_del_ws2812_encoder;
|
||||
led_encoder->base.reset = rmt_ws2812_encoder_reset;
|
||||
|
||||
// WS2812 timing
|
||||
bytes_encoder_config.bit0.level0 = 1;
|
||||
bytes_encoder_config.bit0.duration0 = 0.3 * resolution / 1000000; // T0H=0.3us
|
||||
bytes_encoder_config.bit0.level1 = 0;
|
||||
bytes_encoder_config.bit0.duration1 = 0.9 * resolution / 1000000; // T0L=0.9us
|
||||
bytes_encoder_config.bit1.level0 = 1;
|
||||
bytes_encoder_config.bit1.duration0 = 0.9 * resolution / 1000000; // T1H=0.9us
|
||||
bytes_encoder_config.bit1.level1 = 0;
|
||||
bytes_encoder_config.bit1.duration1 = 0.3 * resolution / 1000000; // T1L=0.3us
|
||||
bytes_encoder_config.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");
|
||||
ESP_GOTO_ON_ERROR(rmt_new_copy_encoder(©_encoder_config, &led_encoder->copy_encoder), err, TAG, "create copy encoder failed");
|
||||
|
||||
reset_ticks = resolution / 1000000 * 50 / 2; // reset code duration defaults to 50us
|
||||
led_encoder->reset_code.level0 = 0;
|
||||
led_encoder->reset_code.duration0 = reset_ticks;
|
||||
led_encoder->reset_code.level1 = 0;
|
||||
led_encoder->reset_code.duration1 = reset_ticks;
|
||||
|
||||
*ret_encoder = &led_encoder->base;
|
||||
return ESP_OK;
|
||||
err:
|
||||
if (led_encoder) {
|
||||
if (led_encoder->bytes_encoder) {
|
||||
rmt_del_encoder(led_encoder->bytes_encoder);
|
||||
}
|
||||
if (led_encoder->copy_encoder) {
|
||||
rmt_del_encoder(led_encoder->copy_encoder);
|
||||
}
|
||||
free(led_encoder);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* ---- WS2812 strip ---- */
|
||||
|
||||
WS2812::WS2812(gpio_num_t gpio, size_t num_leds, uint32_t resolution_hz)
|
||||
: num_leds_(num_leds), pixels_(num_leds * 3, 0), tx_pixels_(num_leds * 3, 0)
|
||||
{
|
||||
rmt_tx_channel_config_t tx_chan_config = {};
|
||||
tx_chan_config.clk_src = RMT_CLK_SRC_DEFAULT;
|
||||
tx_chan_config.gpio_num = gpio;
|
||||
tx_chan_config.mem_block_symbols = 64; // larger blocks reduce flicker
|
||||
tx_chan_config.resolution_hz = resolution_hz;
|
||||
tx_chan_config.trans_queue_depth = 4;
|
||||
ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &channel_));
|
||||
|
||||
ESP_ERROR_CHECK(new_ws2812_encoder(resolution_hz, &encoder_));
|
||||
|
||||
ESP_ERROR_CHECK(rmt_enable(channel_));
|
||||
tx_config_.loop_count = 0; // send once per write()
|
||||
|
||||
ESP_LOGI(TAG, "Strip ready: %zu LEDs on GPIO %d", num_leds_, (int)gpio);
|
||||
}
|
||||
|
||||
WS2812::~WS2812()
|
||||
{
|
||||
if (channel_) {
|
||||
rmt_tx_wait_all_done(channel_, portMAX_DELAY);
|
||||
rmt_disable(channel_);
|
||||
rmt_del_channel(channel_);
|
||||
}
|
||||
if (encoder_) {
|
||||
encoder_->del(encoder_);
|
||||
}
|
||||
}
|
||||
|
||||
void WS2812::set(size_t index, uint8_t r, uint8_t g, uint8_t b)
|
||||
{
|
||||
if (index >= num_leds_) {
|
||||
return;
|
||||
}
|
||||
uint8_t *p = &pixels_[index * 3];
|
||||
p[0] = g;
|
||||
p[1] = r;
|
||||
p[2] = b;
|
||||
}
|
||||
|
||||
void WS2812::fill(uint8_t r, uint8_t g, uint8_t b)
|
||||
{
|
||||
for (size_t i = 0; i < num_leds_; i++) {
|
||||
set(i, r, g, b);
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t WS2812::write()
|
||||
{
|
||||
for (size_t i = 0; i < pixels_.size(); i++) {
|
||||
tx_pixels_[i] = static_cast<uint8_t>(pixels_[i] * brightness_ / 255);
|
||||
}
|
||||
esp_err_t ret = rmt_transmit(channel_, encoder_, tx_pixels_.data(), tx_pixels_.size(), &tx_config_);
|
||||
if (ret != ESP_OK) {
|
||||
return ret;
|
||||
}
|
||||
return rmt_tx_wait_all_done(channel_, portMAX_DELAY);
|
||||
}
|
||||
|
||||
void WS2812::hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r, uint32_t *g, uint32_t *b)
|
||||
{
|
||||
h %= 360; // h -> [0,360]
|
||||
uint32_t rgb_max = v * 2.55f;
|
||||
uint32_t rgb_min = rgb_max * (100 - s) / 100.0f;
|
||||
|
||||
uint32_t i = h / 60;
|
||||
uint32_t diff = h % 60;
|
||||
|
||||
// RGB adjustment amount by hue
|
||||
uint32_t rgb_adj = (rgb_max - rgb_min) * diff / 60;
|
||||
|
||||
switch (i) {
|
||||
case 0:
|
||||
*r = rgb_max;
|
||||
*g = rgb_min + rgb_adj;
|
||||
*b = rgb_min;
|
||||
break;
|
||||
case 1:
|
||||
*r = rgb_max - rgb_adj;
|
||||
*g = rgb_max;
|
||||
*b = rgb_min;
|
||||
break;
|
||||
case 2:
|
||||
*r = rgb_min;
|
||||
*g = rgb_max;
|
||||
*b = rgb_min + rgb_adj;
|
||||
break;
|
||||
case 3:
|
||||
*r = rgb_min;
|
||||
*g = rgb_max - rgb_adj;
|
||||
*b = rgb_max;
|
||||
break;
|
||||
case 4:
|
||||
*r = rgb_min + rgb_adj;
|
||||
*g = rgb_min;
|
||||
*b = rgb_max;
|
||||
break;
|
||||
default:
|
||||
*r = rgb_max;
|
||||
*g = rgb_min;
|
||||
*b = rgb_max - rgb_adj;
|
||||
break;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user