OrgZephyr/zephyr
OrgZephyr
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr.git
1
0
Fork 0
Code Issues Releases Wiki Activity
zephyr/drivers/led_strip/ws2812_i2s.c

266 lines
8.5 KiB
C
Raw Blame History

/*
* Copyright (c) 2022 Jonathan Rico
*
* Adapted from the SPI driver, using the procedure in this blog post:
* https://electronut.in/nrf52-i2s-ws2812/
*
* Note: the word "word" refers to a 32-bit integer unless otherwise stated.
*
* WS/LRCK frequency:
* This refers to the "I2S word or channel select" clock.
* The I2C peripheral sends two 16-bit channel values for each clock period.
* A single LED color (8 data bits) will take up one 32-bit word or one LRCK
* period. This means a standard RGB led will take 3 LRCK periods to transmit.
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT worldsemi_ws2812_i2s
#include <string.h>
#include <zephyr/drivers/led_strip.h>
#define LOG_LEVEL CONFIG_LED_STRIP_LOG_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(ws2812_i2s);
#include <zephyr/device.h>
#include <zephyr/drivers/i2s.h>
#include <zephyr/dt-bindings/led/led.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#define WS2812_I2S_PRE_DELAY_WORDS 1
struct ws2812_i2s_cfg {
struct device const *dev;
size_t tx_buf_bytes;
struct k_mem_slab *mem_slab;
uint8_t num_colors;
const uint8_t *color_mapping;
uint16_t reset_words;
uint32_t lrck_period;
uint32_t extra_wait_time_us;
bool active_low;
uint8_t nibble_one;
uint8_t nibble_zero;
};
/* Serialize an 8-bit color channel value into two 16-bit I2S values (or 1 32-bit
* word).
*/
static inline void ws2812_i2s_ser(uint32_t *word, uint8_t color, const uint8_t sym_one,
const uint8_t sym_zero)
{
*word = 0;
for (uint16_t i = 0; i < 8; i++) {
if ((1 << i) & color) {
*word |= sym_one << (i * 4);
} else {
*word |= sym_zero << (i * 4);
}
}
/* Swap the two I2S values due to the (audio) channel TX order. */
*word = (*word >> 16) | (*word << 16);
}
static int ws2812_strip_update_rgb(const struct device *dev, struct led_rgb *pixels,
size_t num_pixels)
{
const struct ws2812_i2s_cfg *cfg = dev->config;
uint8_t sym_one, sym_zero;
uint32_t reset_word;
uint32_t *tx_buf;
uint32_t flush_time_us;
void *mem_block;
int ret;
if (cfg->active_low) {
sym_one = (~cfg->nibble_one) & 0x0F;
sym_zero = (~cfg->nibble_zero) & 0x0F;
reset_word = 0xFFFFFFFF;
} else {
sym_one = cfg->nibble_one & 0x0F;
sym_zero = cfg->nibble_zero & 0x0F;
reset_word = 0;
}
/* Acquire memory for the I2S payload. */
ret = k_mem_slab_alloc(cfg->mem_slab, &mem_block, K_SECONDS(10));
if (ret < 0) {
LOG_ERR("Unable to allocate mem slab for TX (err %d)", ret);
return -ENOMEM;
}
tx_buf = (uint32_t *)mem_block;
/* Add a pre-data reset, so the first pixel isn't skipped by the strip. */
for (uint16_t i = 0; i < WS2812_I2S_PRE_DELAY_WORDS; i++) {
*tx_buf = reset_word;
tx_buf++;
}
/*
* Convert pixel data into I2S frames. Each frame has pixel data
* in color mapping on-wire format (e.g. GRB, GRBW, RGB, etc).
*/
for (uint16_t i = 0; i < num_pixels; i++) {
for (uint16_t j = 0; j < cfg->num_colors; j++) {
uint8_t pixel;
switch (cfg->color_mapping[j]) {
/* White channel is not supported by LED strip API. */
case LED_COLOR_ID_WHITE:
pixel = 0;
break;
case LED_COLOR_ID_RED:
pixel = pixels[i].r;
break;
case LED_COLOR_ID_GREEN:
pixel = pixels[i].g;
break;
case LED_COLOR_ID_BLUE:
pixel = pixels[i].b;
break;
default:
return -EINVAL;
}
ws2812_i2s_ser(tx_buf, pixel, sym_one, sym_zero);
tx_buf++;
}
}
for (uint16_t i = 0; i < cfg->reset_words; i++) {
*tx_buf = reset_word;
tx_buf++;
}
/* Flush the buffer on the wire. */
ret = i2s_write(cfg->dev, mem_block, cfg->tx_buf_bytes);
if (ret < 0) {
k_mem_slab_free(cfg->mem_slab, mem_block);
LOG_ERR("Failed to write data: %d", ret);
return ret;
}
ret = i2s_trigger(cfg->dev, I2S_DIR_TX, I2S_TRIGGER_START);
if (ret < 0) {
LOG_ERR("Failed to trigger command %d on TX: %d", I2S_TRIGGER_START, ret);
return ret;
}
ret = i2s_trigger(cfg->dev, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
if (ret < 0) {
LOG_ERR("Failed to trigger command %d on TX: %d", I2S_TRIGGER_DRAIN, ret);
return ret;
}
/* Wait until transaction is over */
flush_time_us = cfg->lrck_period * cfg->tx_buf_bytes / sizeof(uint32_t);
k_usleep(flush_time_us + cfg->extra_wait_time_us);
return ret;
}
static int ws2812_strip_update_channels(const struct device *dev, uint8_t *channels,
size_t num_channels)
{
LOG_ERR("update_channels not implemented");
return -ENOTSUP;
}
static int ws2812_i2s_init(const struct device *dev)
{
const struct ws2812_i2s_cfg *cfg = dev->config;
struct i2s_config config;
uint32_t lrck_hz;
int ret;
lrck_hz = USEC_PER_SEC / cfg->lrck_period;
LOG_DBG("Word clock: freq %u Hz period %u us",
lrck_hz, cfg->lrck_period);
/* 16-bit stereo, 100kHz LCLK */
config.word_size = 16;
config.channels = 2;
config.format = I2S_FMT_DATA_FORMAT_I2S;
config.options = I2S_OPT_BIT_CLK_MASTER | I2S_OPT_FRAME_CLK_MASTER;
config.frame_clk_freq = lrck_hz; /* WS (or LRCK) */
config.mem_slab = cfg->mem_slab;
config.block_size = cfg->tx_buf_bytes;
config.timeout = 1000;
ret = i2s_configure(cfg->dev, I2S_DIR_TX, &config);
if (ret < 0) {
LOG_ERR("Failed to configure I2S device: %d\n", ret);
return ret;
}
for (uint16_t i = 0; i < cfg->num_colors; i++) {
switch (cfg->color_mapping[i]) {
case LED_COLOR_ID_WHITE:
case LED_COLOR_ID_RED:
case LED_COLOR_ID_GREEN:
case LED_COLOR_ID_BLUE:
break;
default:
LOG_ERR("%s: invalid channel to color mapping."
"Check the color-mapping DT property",
dev->name);
return -EINVAL;
}
}
return 0;
}
static const struct led_strip_driver_api ws2812_i2s_api = {
.update_rgb = ws2812_strip_update_rgb,
.update_channels = ws2812_strip_update_channels,
};
/* Integer division, but always rounds up: e.g. 10/3 = 4 */
#define WS2812_ROUNDED_DIVISION(x, y) ((x + (y - 1)) / y)
#define WS2812_I2S_LRCK_PERIOD_US(idx) DT_INST_PROP(idx, lrck_period)
#define WS2812_RESET_DELAY_US(idx) DT_INST_PROP(idx, reset_delay)
/* Rounds up to the next 20us. */
#define WS2812_RESET_DELAY_WORDS(idx) WS2812_ROUNDED_DIVISION(WS2812_RESET_DELAY_US(idx), \
WS2812_I2S_LRCK_PERIOD_US(idx))
#define WS2812_NUM_COLORS(idx) (DT_INST_PROP_LEN(idx, color_mapping))
#define WS2812_I2S_NUM_PIXELS(idx) (DT_INST_PROP(idx, chain_length))
#define WS2812_I2S_BUFSIZE(idx) \
(((WS2812_NUM_COLORS(idx) * WS2812_I2S_NUM_PIXELS(idx)) + \
WS2812_I2S_PRE_DELAY_WORDS + WS2812_RESET_DELAY_WORDS(idx)) * 4)
#define WS2812_I2S_DEVICE(idx) \
\
K_MEM_SLAB_DEFINE_STATIC(ws2812_i2s_##idx##_slab, WS2812_I2S_BUFSIZE(idx), 2, 4); \
\
static const uint8_t ws2812_i2s_##idx##_color_mapping[] = \
DT_INST_PROP(idx, color_mapping); \
\
static const struct ws2812_i2s_cfg ws2812_i2s_##idx##_cfg = { \
.dev = DEVICE_DT_GET(DT_INST_PROP(idx, i2s_dev)), \
.tx_buf_bytes = WS2812_I2S_BUFSIZE(idx), \
.mem_slab = &ws2812_i2s_##idx##_slab, \
.num_colors = WS2812_NUM_COLORS(idx), \
.color_mapping = ws2812_i2s_##idx##_color_mapping, \
.lrck_period = WS2812_I2S_LRCK_PERIOD_US(idx), \
.extra_wait_time_us = DT_INST_PROP(idx, extra_wait_time), \
.reset_words = WS2812_RESET_DELAY_WORDS(idx), \
.active_low = DT_INST_PROP(idx, out_active_low), \
.nibble_one = DT_INST_PROP(idx, nibble_one), \
.nibble_zero = DT_INST_PROP(idx, nibble_zero), \
}; \
\
DEVICE_DT_INST_DEFINE(idx, ws2812_i2s_init, NULL, NULL, &ws2812_i2s_##idx##_cfg, \
POST_KERNEL, CONFIG_LED_STRIP_INIT_PRIORITY, &ws2812_i2s_api);
DT_INST_FOREACH_STATUS_OKAY(WS2812_I2S_DEVICE)
Reference in New Issue View Git Blame Copy Permalink