285 lines
9.8 KiB
C
285 lines
9.8 KiB
C
/**
|
|
* @file led_driver.c
|
|
* @brief WS2812B LED Driver
|
|
* @details This driver uses DMA and TIM2 AAR to drive WS2812B LEDs. There is no circular buffer,
|
|
* so all of the data is loaded into memory at the beginning. We are able to driver 256 LEDs.
|
|
*
|
|
*/
|
|
|
|
#include <stm32wbxx_ll_dma.h>
|
|
|
|
#include "led_driver.h"
|
|
|
|
// We store the HIGH/LOW durations (2 values) for each color bit (24 bits per LED)
|
|
#define LED_DRIVER_BUFFER_SIZE (MAX_LED_COUNT * 2 * 24)
|
|
// We use a setinel value to figure out when the timer is complete.
|
|
#define LED_DRIVER_TIMER_SETINEL 0xFFFFU
|
|
|
|
/** 64 transitions per us @ 64MHz. Our timing is in NANO_SECONDS */
|
|
#define LED_DRIVER_TIMER_NANOSECOND (1000U / (SystemCoreClock / 1000000U))
|
|
// Timings for WS2812B
|
|
#define LED_DRIVER_T0H 400U
|
|
#define LED_DRIVER_T1H 800U
|
|
#define LED_DRIVER_T0L 850U
|
|
#define LED_DRIVER_T1L 450U
|
|
#define LED_DRIVER_TRESETL 55 * 1000U
|
|
#define LED_DRIVER_TDONE 2000U
|
|
|
|
// Wait for 35ms for the DMA to complete. NOTE: 1000 leds*(850ns+450ns)*24 = 32ms
|
|
#define LED_DRIVER_SETINEL_WAIT_MS 35
|
|
|
|
struct LedDriver {
|
|
LL_DMA_InitTypeDef dma_gpio_update;
|
|
LL_DMA_InitTypeDef dma_led_transition_timer;
|
|
|
|
const GpioPin* gpio;
|
|
uint32_t gpio_buf[2]; // On/Off for GPIO
|
|
|
|
uint16_t timer_buffer[LED_DRIVER_BUFFER_SIZE + 2];
|
|
uint32_t write_pos;
|
|
uint32_t read_pos;
|
|
bool dirty;
|
|
|
|
uint32_t count_leds;
|
|
uint32_t* led_data;
|
|
};
|
|
|
|
static void led_driver_init_dma_gpio_update(LedDriver* led_driver, const GpioPin* gpio) {
|
|
led_driver->gpio = gpio;
|
|
|
|
// Memory to Peripheral
|
|
led_driver->dma_gpio_update.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
|
// Peripheral (GPIO - We populate GPIO port's BSRR register)
|
|
led_driver->dma_gpio_update.PeriphOrM2MSrcAddress = (uint32_t)&gpio->port->BSRR;
|
|
led_driver->dma_gpio_update.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
|
led_driver->dma_gpio_update.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
|
// Memory (State to set GPIO)
|
|
led_driver->dma_gpio_update.MemoryOrM2MDstAddress = (uint32_t)led_driver->gpio_buf;
|
|
led_driver->dma_gpio_update.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
|
led_driver->dma_gpio_update.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
|
|
// Data
|
|
led_driver->dma_gpio_update.Mode = LL_DMA_MODE_CIRCULAR;
|
|
led_driver->dma_gpio_update.NbData = 2; // We cycle between two (HIGH/LOW)values
|
|
// When to perform data exchange
|
|
led_driver->dma_gpio_update.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
|
|
led_driver->dma_gpio_update.Priority = LL_DMA_PRIORITY_VERYHIGH;
|
|
}
|
|
|
|
static void led_driver_init_dma_led_transition_timer(LedDriver* led_driver) {
|
|
// Timer that triggers based on user data.
|
|
led_driver->dma_led_transition_timer.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
|
// Peripheral (Timer - We populate TIM2's ARR register)
|
|
led_driver->dma_led_transition_timer.PeriphOrM2MSrcAddress = (uint32_t)&TIM2->ARR;
|
|
led_driver->dma_led_transition_timer.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
|
led_driver->dma_led_transition_timer.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
|
// Memory (Timings)
|
|
led_driver->dma_led_transition_timer.MemoryOrM2MDstAddress =
|
|
(uint32_t)led_driver->timer_buffer;
|
|
led_driver->dma_led_transition_timer.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
|
led_driver->dma_led_transition_timer.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_HALFWORD;
|
|
// Data
|
|
led_driver->dma_led_transition_timer.Mode = LL_DMA_MODE_NORMAL;
|
|
led_driver->dma_led_transition_timer.NbData = LED_DRIVER_BUFFER_SIZE;
|
|
// When to perform data exchange
|
|
led_driver->dma_led_transition_timer.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
|
|
led_driver->dma_led_transition_timer.Priority = LL_DMA_PRIORITY_HIGH;
|
|
}
|
|
|
|
LedDriver* led_driver_alloc(int count_leds, const GpioPin* gpio) {
|
|
furi_assert(gpio);
|
|
furi_assert(count_leds && count_leds <= MAX_LED_COUNT);
|
|
|
|
LedDriver* led_driver = malloc(sizeof(LedDriver));
|
|
led_driver_init_dma_gpio_update(led_driver, gpio);
|
|
led_driver_init_dma_led_transition_timer(led_driver);
|
|
led_driver->led_data = malloc(MAX_LED_COUNT * sizeof(uint32_t));
|
|
led_driver->dirty = true;
|
|
|
|
led_driver->count_leds = count_leds;
|
|
|
|
return led_driver;
|
|
}
|
|
|
|
void led_driver_free(LedDriver* led_driver) {
|
|
furi_assert(led_driver);
|
|
|
|
free(led_driver->led_data);
|
|
free(led_driver);
|
|
}
|
|
|
|
void led_driver_set_pin(LedDriver* led_driver, const GpioPin* gpio) {
|
|
if(led_driver->gpio == gpio) {
|
|
return;
|
|
}
|
|
|
|
led_driver_init_dma_gpio_update(led_driver, gpio);
|
|
led_driver->dirty = true;
|
|
}
|
|
|
|
uint32_t led_driver_set_led(LedDriver* led_driver, uint32_t index, uint32_t rrggbb) {
|
|
furi_assert(led_driver);
|
|
if(index >= led_driver->count_leds) {
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
uint32_t previous = led_driver->led_data[index];
|
|
led_driver->led_data[index] = rrggbb;
|
|
led_driver->dirty |= previous != rrggbb;
|
|
|
|
return previous;
|
|
}
|
|
|
|
uint32_t led_driver_get_led(LedDriver* led_driver, uint32_t index) {
|
|
furi_assert(led_driver);
|
|
if(index >= led_driver->count_leds) {
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
return led_driver->led_data[index];
|
|
}
|
|
|
|
static void led_driver_start_dma(LedDriver* led_driver) {
|
|
furi_assert(led_driver);
|
|
|
|
LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &led_driver->dma_gpio_update);
|
|
LL_DMA_Init(DMA1, LL_DMA_CHANNEL_2, &led_driver->dma_led_transition_timer);
|
|
|
|
LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
|
|
LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2);
|
|
}
|
|
|
|
static void led_driver_start_timer() {
|
|
furi_hal_bus_enable(FuriHalBusTIM2);
|
|
|
|
LL_TIM_SetCounterMode(TIM2, LL_TIM_COUNTERMODE_UP);
|
|
LL_TIM_SetClockDivision(TIM2, LL_TIM_CLOCKDIVISION_DIV1);
|
|
LL_TIM_SetPrescaler(TIM2, 0);
|
|
// Updated by led_driver->dma_led_transition_timer.PeriphOrM2MSrcAddress
|
|
LL_TIM_SetAutoReload(TIM2, LED_DRIVER_TIMER_SETINEL);
|
|
LL_TIM_SetCounter(TIM2, 0);
|
|
|
|
LL_TIM_EnableCounter(TIM2);
|
|
LL_TIM_EnableUpdateEvent(TIM2);
|
|
LL_TIM_EnableDMAReq_UPDATE(TIM2);
|
|
LL_TIM_GenerateEvent_UPDATE(TIM2);
|
|
}
|
|
|
|
static void led_driver_stop_timer() {
|
|
LL_TIM_DisableCounter(TIM2);
|
|
LL_TIM_DisableUpdateEvent(TIM2);
|
|
LL_TIM_DisableDMAReq_UPDATE(TIM2);
|
|
furi_hal_bus_disable(FuriHalBusTIM2);
|
|
}
|
|
|
|
static void led_driver_stop_dma() {
|
|
LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_1);
|
|
LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_2);
|
|
LL_DMA_ClearFlag_TC1(DMA1);
|
|
LL_DMA_ClearFlag_TC2(DMA1);
|
|
}
|
|
|
|
static void led_driver_spin_lock(LedDriver* led_driver) {
|
|
const uint32_t prev_timer = DWT->CYCCNT;
|
|
const uint32_t wait_time = LED_DRIVER_SETINEL_WAIT_MS * SystemCoreClock / 1000;
|
|
|
|
do {
|
|
/* Make sure it's started (allow 100 ticks), but then check for sentinel value. */
|
|
if(TIM2->ARR == LED_DRIVER_TIMER_SETINEL && DWT->CYCCNT - prev_timer > 100) {
|
|
break;
|
|
}
|
|
|
|
// 0xFF is fairly quick, make sure we didn't miss it.
|
|
if((DWT->CYCCNT - prev_timer > wait_time)) {
|
|
FURI_LOG_D(
|
|
"Demo", "0xFF not found (ARR 0x%08lx, read %lu)", TIM2->ARR, led_driver->read_pos);
|
|
led_driver->read_pos = led_driver->write_pos - 1;
|
|
break;
|
|
}
|
|
} while(true);
|
|
}
|
|
|
|
static void led_driver_add_period_length(LedDriver* led_driver, uint32_t length) {
|
|
led_driver->timer_buffer[led_driver->write_pos++] = length;
|
|
led_driver->timer_buffer[led_driver->write_pos] = LED_DRIVER_TIMER_SETINEL;
|
|
}
|
|
|
|
static void led_driver_add_period(LedDriver* led_driver, uint16_t duration_ns) {
|
|
furi_assert(led_driver);
|
|
|
|
uint32_t reload_value = duration_ns / LED_DRIVER_TIMER_NANOSECOND;
|
|
|
|
if(reload_value > 255) {
|
|
FURI_LOG_E("Demo", "reload_value: %ld", reload_value);
|
|
}
|
|
furi_check(reload_value > 0);
|
|
furi_check(reload_value < 256 * 256);
|
|
|
|
led_driver_add_period_length(led_driver, reload_value - 1);
|
|
}
|
|
|
|
static void led_driver_add_color(LedDriver* led_driver, uint32_t rrggbb) {
|
|
UNUSED(rrggbb);
|
|
|
|
uint32_t ggrrbb = (rrggbb & 0xFF) | ((rrggbb & 0xFF00) << 8) | ((rrggbb & 0xFF0000) >> 8);
|
|
|
|
for(int i = 23; i >= 0; i--) {
|
|
if(ggrrbb & (1 << i)) {
|
|
led_driver_add_period(led_driver, LED_DRIVER_T0L);
|
|
led_driver_add_period(led_driver, LED_DRIVER_T1L);
|
|
} else {
|
|
led_driver_add_period(led_driver, LED_DRIVER_T0H);
|
|
led_driver_add_period(led_driver, LED_DRIVER_T1H);
|
|
}
|
|
}
|
|
}
|
|
|
|
void led_driver_transmit(LedDriver* led_driver, bool transmit_if_clean) {
|
|
furi_assert(led_driver);
|
|
|
|
furi_assert(!led_driver->read_pos);
|
|
furi_assert(!led_driver->write_pos);
|
|
|
|
if(!transmit_if_clean && !led_driver->dirty) {
|
|
FURI_LOG_D("LED_DRIVER", "Skipping transmit");
|
|
return;
|
|
}
|
|
FURI_LOG_D("LED_DRIVER", "Transmit");
|
|
|
|
furi_hal_gpio_init(led_driver->gpio, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
|
|
furi_hal_gpio_write(led_driver->gpio, false);
|
|
|
|
const uint32_t bit_set = led_driver->gpio->pin << GPIO_BSRR_BS0_Pos;
|
|
const uint32_t bit_reset = led_driver->gpio->pin << GPIO_BSRR_BR0_Pos;
|
|
|
|
// Our initial state is LOW, so first pulse is HIGH (set)
|
|
led_driver->gpio_buf[0] = bit_set;
|
|
led_driver->gpio_buf[1] = bit_reset;
|
|
|
|
for(size_t i = 0; i < LED_DRIVER_BUFFER_SIZE; i++) {
|
|
led_driver->timer_buffer[i] = LED_DRIVER_TIMER_SETINEL;
|
|
}
|
|
|
|
for(size_t i = 0; i < led_driver->count_leds; i++) {
|
|
led_driver_add_color(led_driver, led_driver->led_data[i]);
|
|
}
|
|
led_driver_add_period(led_driver, LED_DRIVER_TDONE);
|
|
led_driver->dma_led_transition_timer.NbData = led_driver->write_pos + 1;
|
|
|
|
FURI_CRITICAL_ENTER();
|
|
|
|
led_driver_start_dma(led_driver);
|
|
led_driver_start_timer();
|
|
|
|
led_driver_spin_lock(led_driver);
|
|
|
|
led_driver_stop_timer();
|
|
led_driver_stop_dma();
|
|
|
|
FURI_CRITICAL_EXIT();
|
|
|
|
memset(led_driver->timer_buffer, LED_DRIVER_TIMER_SETINEL, LED_DRIVER_BUFFER_SIZE);
|
|
led_driver->read_pos = 0;
|
|
led_driver->write_pos = 0;
|
|
led_driver->dirty = false;
|
|
}
|