300 lines
10 KiB
C
300 lines
10 KiB
C
|
#include "led_driver_i.h"
|
||
|
|
|
||
|
|
#define TAG "led_driver"
|
||
|
|
|
||
|
|
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;
|
||
|
|
|
||
|
|
uint32_t count_leds;
|
||
|
|
uint32_t* led_data;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Initializes the DMA for GPIO pin toggle via BSRR.
|
||
|
|
* @param led_driver The led driver to initialize.
|
||
|
|
* @param gpio The GPIO pin to toggle.
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Initializes the DMA for the LED timings via ARR.
|
||
|
|
* @param led_driver The led driver to initialize.
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Allocate and initialize LedDriver structure.
|
||
|
|
* @details This function allocate and initialize LedDriver structure.
|
||
|
|
* @return Pointer to allocated LedDriver structure.
|
||
|
|
*/
|
||
|
|
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->count_leds = count_leds;
|
||
|
|
|
||
|
|
return led_driver;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Frees a led driver.
|
||
|
|
* @details Frees a led driver.
|
||
|
|
* @param led_driver The led driver to free.
|
||
|
|
*/
|
||
|
|
void led_driver_free(LedDriver* led_driver) {
|
||
|
|
furi_assert(led_driver);
|
||
|
|
|
||
|
|
furi_hal_gpio_init_simple(led_driver->gpio, GpioModeAnalog);
|
||
|
|
free(led_driver->led_data);
|
||
|
|
free(led_driver);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the LED at the given index to the given color.
|
||
|
|
* @note You must still call led_driver_transmit to actually update the LEDs.
|
||
|
|
* @param led_driver The led driver to use.
|
||
|
|
* @param index The index of the LED to set.
|
||
|
|
* @param rrggbb The color to set the LED to (0xrrggbb format).
|
||
|
|
* @return The previous color of the LED (0xrrggbb format).
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
return previous;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Gets the LED at the given index.
|
||
|
|
* @param led_driver The led driver to use.
|
||
|
|
* @param index The index of the LED to get.
|
||
|
|
* @return The color of the LED (0xrrggbb format).
|
||
|
|
*/
|
||
|
|
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];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Initializes the DMA for GPIO pin toggle and led transititions.
|
||
|
|
* @param led_driver The led driver to initialize.
|
||
|
|
*/
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Stops the DMA for GPIO pin toggle and led transititions.
|
||
|
|
* @param led_driver The led driver to initialize.
|
||
|
|
*/
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Starts the timer for led transitions.
|
||
|
|
* @param led_driver The led driver to initialize.
|
||
|
|
*/
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Stops the timer for led transitions.
|
||
|
|
* @param led_driver The led driver to initialize.
|
||
|
|
*/
|
||
|
|
static void led_driver_stop_timer() {
|
||
|
|
LL_TIM_DisableCounter(TIM2);
|
||
|
|
LL_TIM_DisableUpdateEvent(TIM2);
|
||
|
|
LL_TIM_DisableDMAReq_UPDATE(TIM2);
|
||
|
|
furi_hal_bus_disable(FuriHalBusTIM2);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Waits for the DMA to complete.
|
||
|
|
* @param led_driver The led driver to use.
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
// We should have seen it above, but just in case we also have a timeout.
|
||
|
|
if((DWT->CYCCNT - prev_timer > wait_time)) {
|
||
|
|
FURI_LOG_E(
|
||
|
|
TAG,
|
||
|
|
"0x%04x not found (ARR 0x%08lx, read %lu)",
|
||
|
|
LED_DRIVER_TIMER_SETINEL,
|
||
|
|
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(TAG, "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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Send the LED data to the LEDs.
|
||
|
|
* @param led_driver The led driver to use.
|
||
|
|
*/
|
||
|
|
void led_driver_transmit(LedDriver* led_driver) {
|
||
|
|
furi_assert(led_driver);
|
||
|
|
|
||
|
|
furi_assert(!led_driver->read_pos);
|
||
|
|
furi_assert(!led_driver->write_pos);
|
||
|
|
|
||
|
|
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;
|
||
|
|
|
||
|
|
// Always start with HIGH
|
||
|
|
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;
|
||
|
|
}
|