ESPHome 2025.5.0
Loading...
Searching...
No Matches
led_strip.cpp
Go to the documentation of this file.
1#include "led_strip.h"
2
3#ifdef USE_BK72XX
4
6#include "esphome/core/log.h"
7
8extern "C" {
9#include "rtos_pub.h"
10#include "spi.h"
11#include "arm_arch.h"
12#include "general_dma_pub.h"
13#include "gpio_pub.h"
14#include "icu_pub.h"
15#undef SPI_DAT
16#undef SPI_BASE
17};
18
19static const uint32_t SPI_TX_DMA_CHANNEL = GDMA_CHANNEL_3;
20
21// TODO: Check if SPI_PERI_CLK_DCO depends on the chip variant
22static const uint32_t SPI_PERI_CLK_26M = 26000000;
23static const uint32_t SPI_PERI_CLK_DCO = 120000000;
24
25static const uint32_t SPI_BASE = 0x00802700;
26static const uint32_t SPI_DAT = SPI_BASE + 3 * 4;
27static const uint32_t SPI_CONFIG = SPI_BASE + 1 * 4;
28
29static const uint32_t SPI_TX_EN = 1 << 0;
30static const uint32_t CTRL_NSSMD_3 = 1 << 17;
31static const uint32_t SPI_TX_FINISH_EN = 1 << 2;
32static const uint32_t SPI_RX_FINISH_EN = 1 << 3;
33
34namespace esphome {
35namespace beken_spi_led_strip {
36
37static const char *const TAG = "beken_spi_led_strip";
38
39struct spi_data_t {
40 SemaphoreHandle_t dma_tx_semaphore;
41 volatile bool tx_in_progress;
42 bool first_run;
43};
44
45static spi_data_t *spi_data = nullptr;
46
47static void set_spi_ctrl_register(unsigned long bit, bool val) {
48 uint32_t value = REG_READ(SPI_CTRL);
49 if (val == 0) {
50 value &= ~bit;
51 } else if (val == 1) {
52 value |= bit;
53 }
54 REG_WRITE(SPI_CTRL, value);
55}
56
57static void set_spi_config_register(unsigned long bit, bool val) {
58 uint32_t value = REG_READ(SPI_CONFIG);
59 if (val == 0) {
60 value &= ~bit;
61 } else if (val == 1) {
62 value |= bit;
63 }
64 REG_WRITE(SPI_CONFIG, value);
65}
66
67void spi_dma_tx_enable(bool enable) {
68 GDMA_CFG_ST en_cfg;
69 set_spi_config_register(SPI_TX_EN, enable ? 1 : 0);
70 en_cfg.channel = SPI_TX_DMA_CHANNEL;
71 en_cfg.param = enable ? 1 : 0;
72 sddev_control(GDMA_DEV_NAME, CMD_GDMA_SET_DMA_ENABLE, &en_cfg);
73}
74
75static void spi_set_clock(uint32_t max_hz) {
76 int source_clk = 0;
77 int spi_clk = 0;
78 int div = 0;
79 uint32_t param;
80 if (max_hz > 4333000) {
81 if (max_hz > 30000000) {
82 spi_clk = 30000000;
83 } else {
84 spi_clk = max_hz;
85 }
86 sddev_control(ICU_DEV_NAME, CMD_CLK_PWR_DOWN, &param);
87 source_clk = SPI_PERI_CLK_DCO;
88 param = PCLK_POSI_SPI;
89 sddev_control(ICU_DEV_NAME, CMD_CONF_PCLK_DCO, &param);
90 param = PWD_SPI_CLK_BIT;
91 sddev_control(ICU_DEV_NAME, CMD_CLK_PWR_UP, &param);
92 } else {
93 spi_clk = max_hz;
94#if CFG_XTAL_FREQUENCE
95 source_clk = CFG_XTAL_FREQUENCE;
96#else
97 source_clk = SPI_PERI_CLK_26M;
98#endif
99 param = PCLK_POSI_SPI;
100 sddev_control(ICU_DEV_NAME, CMD_CONF_PCLK_26M, &param);
101 }
102 div = ((source_clk >> 1) / spi_clk);
103 if (div < 2) {
104 div = 2;
105 } else if (div >= 255) {
106 div = 255;
107 }
108 param = REG_READ(SPI_CTRL);
109 param &= ~(SPI_CKR_MASK << SPI_CKR_POSI);
110 param |= (div << SPI_CKR_POSI);
111 REG_WRITE(SPI_CTRL, param);
112 ESP_LOGD(TAG, "target frequency: %d, actual frequency: %d", max_hz, source_clk / 2 / div);
113}
114
115void spi_dma_tx_finish_callback(unsigned int param) {
116 spi_data->tx_in_progress = false;
117 xSemaphoreGive(spi_data->dma_tx_semaphore);
119}
120
122 ESP_LOGCONFIG(TAG, "Setting up Beken SPI LED Strip...");
123
124 size_t buffer_size = this->get_buffer_size_();
125 size_t dma_buffer_size = (buffer_size * 8) + (2 * 64);
126
128 this->buf_ = allocator.allocate(buffer_size);
129 if (this->buf_ == nullptr) {
130 ESP_LOGE(TAG, "Cannot allocate LED buffer!");
131 this->mark_failed();
132 return;
133 }
134
135 this->effect_data_ = allocator.allocate(this->num_leds_);
136 if (this->effect_data_ == nullptr) {
137 ESP_LOGE(TAG, "Cannot allocate effect data!");
138 this->mark_failed();
139 return;
140 }
141
142 this->dma_buf_ = allocator.allocate(dma_buffer_size);
143 if (this->dma_buf_ == nullptr) {
144 ESP_LOGE(TAG, "Cannot allocate DMA buffer!");
145 this->mark_failed();
146 return;
147 }
148
149 memset(this->buf_, 0, buffer_size);
150 memset(this->effect_data_, 0, this->num_leds_);
151 memset(this->dma_buf_, 0, dma_buffer_size);
152
153 uint32_t value = PCLK_POSI_SPI;
154 sddev_control(ICU_DEV_NAME, CMD_CONF_PCLK_26M, &value);
155
156 value = PWD_SPI_CLK_BIT;
157 sddev_control(ICU_DEV_NAME, CMD_CLK_PWR_UP, &value);
158
159 if (spi_data != nullptr) {
160 ESP_LOGE(TAG, "SPI device already initialized!");
161 this->mark_failed();
162 return;
163 }
164
165 spi_data = (spi_data_t *) calloc(1, sizeof(spi_data_t));
166 if (spi_data == nullptr) {
167 ESP_LOGE(TAG, "Cannot allocate spi_data!");
168 this->mark_failed();
169 return;
170 }
171
172 spi_data->dma_tx_semaphore = xSemaphoreCreateBinary();
173 if (spi_data->dma_tx_semaphore == nullptr) {
174 ESP_LOGE(TAG, "TX Semaphore init faild!");
175 this->mark_failed();
176 return;
177 }
178
179 spi_data->first_run = true;
180
181 set_spi_ctrl_register(MSTEN, 0);
182 set_spi_ctrl_register(BIT_WDTH, 0);
183 spi_set_clock(this->spi_frequency_);
184 set_spi_ctrl_register(CKPOL, 0);
185 set_spi_ctrl_register(CKPHA, 0);
186 set_spi_ctrl_register(MSTEN, 1);
187 set_spi_ctrl_register(SPIEN, 1);
188
189 set_spi_ctrl_register(TXINT_EN, 0);
190 set_spi_ctrl_register(RXINT_EN, 0);
191 set_spi_config_register(SPI_TX_FINISH_EN, 1);
192 set_spi_config_register(SPI_RX_FINISH_EN, 1);
193 set_spi_ctrl_register(RXOVR_EN, 0);
194 set_spi_ctrl_register(TXOVR_EN, 0);
195
196 value = REG_READ(SPI_CTRL);
197 value &= ~CTRL_NSSMD_3;
198 value |= (1 << 17);
199 REG_WRITE(SPI_CTRL, value);
200
201 value = GFUNC_MODE_SPI_DMA;
202 sddev_control(GPIO_DEV_NAME, CMD_GPIO_ENABLE_SECOND, &value);
203 set_spi_ctrl_register(SPI_S_CS_UP_INT_EN, 0);
204
205 GDMA_CFG_ST en_cfg;
206 GDMACFG_TPYES_ST init_cfg;
207 memset(&init_cfg, 0, sizeof(GDMACFG_TPYES_ST));
208
209 init_cfg.dstdat_width = 8;
210 init_cfg.srcdat_width = 32;
211 init_cfg.dstptr_incr = 0;
212 init_cfg.srcptr_incr = 1;
213 init_cfg.src_start_addr = this->dma_buf_;
214 init_cfg.dst_start_addr = (void *) SPI_DAT; // SPI_DMA_REG4_TXFIFO
215 init_cfg.channel = SPI_TX_DMA_CHANNEL;
216 init_cfg.prio = 0; // 10
217 init_cfg.u.type4.src_loop_start_addr = this->dma_buf_;
218 init_cfg.u.type4.src_loop_end_addr = this->dma_buf_ + dma_buffer_size;
219 init_cfg.half_fin_handler = nullptr;
220 init_cfg.fin_handler = spi_dma_tx_finish_callback;
221 init_cfg.src_module = GDMA_X_SRC_DTCM_RD_REQ;
222 init_cfg.dst_module = GDMA_X_DST_GSPI_TX_REQ; // GDMA_X_DST_HSSPI_TX_REQ
223 sddev_control(GDMA_DEV_NAME, CMD_GDMA_CFG_TYPE4, (void *) &init_cfg);
224 en_cfg.channel = SPI_TX_DMA_CHANNEL;
225 en_cfg.param = dma_buffer_size;
226 sddev_control(GDMA_DEV_NAME, CMD_GDMA_SET_TRANS_LENGTH, (void *) &en_cfg);
227 en_cfg.channel = SPI_TX_DMA_CHANNEL;
228 en_cfg.param = 0;
229 sddev_control(GDMA_DEV_NAME, CMD_GDMA_CFG_WORK_MODE, (void *) &en_cfg);
230 en_cfg.channel = SPI_TX_DMA_CHANNEL;
231 en_cfg.param = 0;
232 sddev_control(GDMA_DEV_NAME, CMD_GDMA_CFG_SRCADDR_LOOP, &en_cfg);
233
235
236 value = REG_READ(SPI_CONFIG);
237 value &= ~(0xFFF << 8);
238 value |= ((dma_buffer_size & 0xFFF) << 8);
239 REG_WRITE(SPI_CONFIG, value);
240}
241
242void BekenSPILEDStripLightOutput::set_led_params(uint8_t bit0, uint8_t bit1, uint32_t spi_frequency) {
243 this->bit0_ = bit0;
244 this->bit1_ = bit1;
245 this->spi_frequency_ = spi_frequency;
246}
247
249 // protect from refreshing too often
250 uint32_t now = micros();
251 if (*this->max_refresh_rate_ != 0 && (now - this->last_refresh_) < *this->max_refresh_rate_) {
252 // try again next loop iteration, so that this change won't get lost
253 this->schedule_show();
254 return;
255 }
256 this->last_refresh_ = now;
257 this->mark_shown_();
258
259 ESP_LOGVV(TAG, "Writing RGB values to bus...");
260
261 if (spi_data == nullptr) {
262 ESP_LOGE(TAG, "SPI not initialized");
263 this->status_set_warning();
264 return;
265 }
266
267 if (!spi_data->first_run && !xSemaphoreTake(spi_data->dma_tx_semaphore, 10 / portTICK_PERIOD_MS)) {
268 ESP_LOGE(TAG, "Timed out waiting for semaphore");
269 return;
270 }
271
272 if (spi_data->tx_in_progress) {
273 ESP_LOGE(TAG, "tx_in_progress is set");
274 this->status_set_warning();
275 return;
276 }
277
278 spi_data->tx_in_progress = true;
279
280 size_t buffer_size = this->get_buffer_size_();
281 size_t size = 0;
282 uint8_t *psrc = this->buf_;
283 uint8_t *pdest = this->dma_buf_ + 64;
284 // The 64 byte padding is a workaround for a SPI DMA bug where the
285 // output doesn't exactly start at the beginning of dma_buf_
286
287 while (size < buffer_size) {
288 uint8_t b = *psrc;
289 for (int i = 0; i < 8; i++) {
290 *pdest++ = b & (1 << (7 - i)) ? this->bit1_ : this->bit0_;
291 }
292 size++;
293 psrc++;
294 }
295
296 spi_data->first_run = false;
298
299 this->status_clear_warning();
300}
301
303 int32_t r = 0, g = 0, b = 0;
304 switch (this->rgb_order_) {
305 case ORDER_RGB:
306 r = 0;
307 g = 1;
308 b = 2;
309 break;
310 case ORDER_RBG:
311 r = 0;
312 g = 2;
313 b = 1;
314 break;
315 case ORDER_GRB:
316 r = 1;
317 g = 0;
318 b = 2;
319 break;
320 case ORDER_GBR:
321 r = 2;
322 g = 0;
323 b = 1;
324 break;
325 case ORDER_BGR:
326 r = 2;
327 g = 1;
328 b = 0;
329 break;
330 case ORDER_BRG:
331 r = 1;
332 g = 2;
333 b = 0;
334 break;
335 }
336 uint8_t multiplier = this->is_rgbw_ || this->is_wrgb_ ? 4 : 3;
337 uint8_t white = this->is_wrgb_ ? 0 : 3;
338
339 return {this->buf_ + (index * multiplier) + r + this->is_wrgb_,
340 this->buf_ + (index * multiplier) + g + this->is_wrgb_,
341 this->buf_ + (index * multiplier) + b + this->is_wrgb_,
342 this->is_rgbw_ || this->is_wrgb_ ? this->buf_ + (index * multiplier) + white : nullptr,
343 &this->effect_data_[index],
344 &this->correction_};
345}
346
348 ESP_LOGCONFIG(TAG, "Beken SPI LED Strip:");
349 ESP_LOGCONFIG(TAG, " Pin: %u", this->pin_);
350 const char *rgb_order;
351 switch (this->rgb_order_) {
352 case ORDER_RGB:
353 rgb_order = "RGB";
354 break;
355 case ORDER_RBG:
356 rgb_order = "RBG";
357 break;
358 case ORDER_GRB:
359 rgb_order = "GRB";
360 break;
361 case ORDER_GBR:
362 rgb_order = "GBR";
363 break;
364 case ORDER_BGR:
365 rgb_order = "BGR";
366 break;
367 case ORDER_BRG:
368 rgb_order = "BRG";
369 break;
370 default:
371 rgb_order = "UNKNOWN";
372 break;
373 }
374 ESP_LOGCONFIG(TAG, " RGB Order: %s", rgb_order);
375 ESP_LOGCONFIG(TAG, " Max refresh rate: %" PRIu32, *this->max_refresh_rate_);
376 ESP_LOGCONFIG(TAG, " Number of LEDs: %u", this->num_leds_);
377}
378
380
381} // namespace beken_spi_led_strip
382} // namespace esphome
383
384#endif // USE_BK72XX
virtual void mark_failed()
Mark this component as failed.
void status_set_warning(const char *message="unspecified")
void status_clear_warning()
An STL allocator that uses SPI or internal RAM.
Definition helpers.h:683
T * allocate(size_t n)
Definition helpers.h:703
void set_led_params(uint8_t bit0, uint8_t bit1, uint32_t spi_frequency)
light::ESPColorView get_view_internal(int32_t index) const override
void write_state(light::LightState *state) override
This class represents the communication layer between the front-end MQTT layer and the hardware outpu...
Definition light_state.h:63
bool state
Definition fan.h:0
mopeka_std_values val[4]
void spi_dma_tx_enable(bool enable)
Definition led_strip.cpp:67
void spi_dma_tx_finish_callback(unsigned int param)
const float HARDWARE
For components that deal with hardware and are very important like GPIO switch.
Definition component.cpp:18
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
uint32_t IRAM_ATTR HOT micros()
Definition core.cpp:29