/* * SPDX-License-Identifier: Apache-2.0 */ #include "ws2812.h" #include #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(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(state | RMT_ENCODING_COMPLETE); } if (session_state & RMT_ENCODING_MEM_FULL) { state = static_cast(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_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(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; } }