183 lines
7.0 KiB
C++
183 lines
7.0 KiB
C++
/*
|
|
* WS2812.cpp
|
|
*
|
|
* Created on: 2 May 2021
|
|
* Author: Ralim
|
|
*/
|
|
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include <WS2812.h>
|
|
#include <string.h>
|
|
uint8_t WS2812::leds_colors[WS2812_LED_CHANNEL_COUNT * WS2812_LED_COUNT];
|
|
volatile uint16_t WS2812::tmp_led_data[2 * WS2812_RAW_BYTES_PER_LED];
|
|
volatile uint8_t WS2812::is_reset_pulse; /*!< Status if we are sending reset pulse or led data */
|
|
volatile uint8_t WS2812::is_updating; /*!< Is updating in progress? */
|
|
volatile uint32_t WS2812::current_led; /*!< Current LED number we are sending */
|
|
|
|
void WS2812::init(void) {
|
|
memset(leds_colors, 0, sizeof(leds_colors));
|
|
hdma_tim1_ch1.XferHalfCpltCallback = DMAHalfComplete;
|
|
hdma_tim1_ch1.XferCpltCallback = DMAComplete;
|
|
htim1.Instance->CCR1 = htim1.Instance->ARR / 2 - 1;
|
|
htim1.Instance->DIER |= TIM_DIER_CC1DE;
|
|
}
|
|
|
|
uint8_t WS2812::led_update(uint8_t block) {
|
|
if (is_updating) { /* Check if update in progress already */
|
|
return 0;
|
|
}
|
|
is_updating = 1; /* We are now updating */
|
|
|
|
led_start_reset_pulse(1); /* Start reset pulse */
|
|
if (block) {
|
|
while (!led_is_update_finished()) {
|
|
vTaskDelay(1);
|
|
}; /* Wait to finish */
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void WS2812::led_set_color(size_t index, uint8_t r, uint8_t g, uint8_t b) {
|
|
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 0] = r;
|
|
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 1] = g;
|
|
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 2] = b;
|
|
}
|
|
|
|
void WS2812::led_set_color_all(uint8_t r, uint8_t g, uint8_t b) {
|
|
for (int index = 0; index < WS2812_LED_COUNT; index++) {
|
|
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 0] = r;
|
|
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 1] = g;
|
|
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 2] = b;
|
|
}
|
|
}
|
|
|
|
uint8_t WS2812::led_is_update_finished(void) { return !is_updating; }
|
|
|
|
void WS2812::led_start_reset_pulse(uint8_t num) {
|
|
is_reset_pulse = num; /* Set reset pulse flag */
|
|
|
|
memset((void *)tmp_led_data, 0, sizeof(tmp_led_data)); /* Set all bytes to 0 to achieve 50us pulse */
|
|
|
|
if (num == 1) {
|
|
tmp_led_data[0] = (htim1.Instance->ARR * 2) / 3; // start with half width pulse
|
|
}
|
|
|
|
/* Set DMA to normal mode, set memory to beginning of data and length to 40 elements */
|
|
/* 800kHz PWM x 40 samples = ~50us pulse low */
|
|
hdma_tim1_ch1.Instance->CCR &= (~DMA_CCR_CIRC); // clear circular flag -> normal mode
|
|
hdma_tim1_ch1.State = HAL_DMA_STATE_READY;
|
|
HAL_DMA_Start_IT(&hdma_tim1_ch1, (uint32_t)tmp_led_data, (uint32_t)&htim1.Instance->CCR1, 2 * WS2812_RAW_BYTES_PER_LED);
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
|
|
}
|
|
|
|
void WS2812::DMAHalfComplete(DMA_HandleTypeDef *hdma) { led_update_sequence(0); }
|
|
|
|
void WS2812::DMAComplete(DMA_HandleTypeDef *hdma) { led_update_sequence(1); }
|
|
|
|
void WS2812::led_update_sequence(uint8_t tc) {
|
|
tc = !!tc; /* Convert to 1 or 0 value only */
|
|
|
|
/* Check for reset pulse at the end of PWM stream */
|
|
if (is_reset_pulse == 2) { /* Check for reset pulse at the end */
|
|
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
|
|
HAL_DMA_Abort(&hdma_tim1_ch1);
|
|
is_updating = 0; /* We are not updating anymore */
|
|
return;
|
|
}
|
|
|
|
/* Check for reset pulse on beginning of PWM stream */
|
|
if (is_reset_pulse == 1) { /* Check if we finished with reset pulse */
|
|
/*
|
|
* When reset pulse is active, we have to wait full DMA response,
|
|
* before we can start modifying array which is shared with DMA and PWM
|
|
*/
|
|
if (!tc) { /* We must wait for transfer complete */
|
|
return; /* Return and wait to finish */
|
|
}
|
|
|
|
/* Disable timer output and disable DMA stream */
|
|
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
|
|
HAL_DMA_Abort(&hdma_tim1_ch1);
|
|
|
|
is_reset_pulse = 0; /* Not in reset pulse anymore */
|
|
current_led = 0; /* Reset current led */
|
|
} else {
|
|
/*
|
|
* When we are not in reset mode,
|
|
* go to next led and process data for it
|
|
*/
|
|
current_led++; /* Go to next LED */
|
|
}
|
|
|
|
/*
|
|
* This part is used to prepare data for "next" led,
|
|
* for which update will start once current transfer stops in circular mode
|
|
*/
|
|
if (current_led < WS2812_LED_COUNT) {
|
|
/*
|
|
* If we are preparing data for first time (current_led == 0)
|
|
* or if there was no TC event (it was HT):
|
|
*
|
|
* - Prepare first part of array, because either there is no transfer
|
|
* or second part (from HT to TC) is now in process for PWM transfer
|
|
*
|
|
* In other case (TC = 1)
|
|
*/
|
|
if (current_led == 0 || !tc) {
|
|
led_fill_led_pwm_data(current_led, &tmp_led_data[0]);
|
|
} else {
|
|
led_fill_led_pwm_data(current_led, &tmp_led_data[WS2812_RAW_BYTES_PER_LED]);
|
|
}
|
|
|
|
/*
|
|
* If we are preparing first led (current_led = 0), then:
|
|
*
|
|
* - We setup first part of array for first led,
|
|
* - We have to prepare second part for second led to have one led prepared in advance
|
|
* - Set DMA to circular mode and start the transfer + PWM output
|
|
*/
|
|
if (current_led == 0) {
|
|
|
|
current_led++; /* Go to next LED */
|
|
led_fill_led_pwm_data(current_led, &tmp_led_data[WS2812_RAW_BYTES_PER_LED]); /* Prepare second LED too */
|
|
hdma_tim1_ch1.Instance->CCR |= (DMA_CCR_CIRC); // set circular flag for circular mode
|
|
hdma_tim1_ch1.State = HAL_DMA_STATE_READY;
|
|
HAL_DMA_Start_IT(&hdma_tim1_ch1, (uint32_t)tmp_led_data, (uint32_t)&htim1.Instance->CCR1, 2 * WS2812_RAW_BYTES_PER_LED);
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
|
|
}
|
|
|
|
/*
|
|
* When we reached all leds, we have to wait to transmit data for all leds before we can disable DMA and PWM:
|
|
*
|
|
* - If TC event is enabled and we have EVEN number of LEDS (2, 4, 6, ...)
|
|
* - If HT event is enabled and we have ODD number of LEDS (1, 3, 5, ...)
|
|
*/
|
|
} else if ((!tc && (WS2812_LED_COUNT & 0x01)) || (tc && !(WS2812_LED_COUNT & 0x01))) {
|
|
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
|
|
HAL_DMA_Abort(&hdma_tim1_ch1);
|
|
|
|
/* It is time to send final reset pulse, 50us at least */
|
|
led_start_reset_pulse(2); /* Start reset pulse at the end */
|
|
}
|
|
}
|
|
|
|
void WS2812::led_fill_led_pwm_data(size_t ledx, volatile uint16_t *ptr) {
|
|
size_t i;
|
|
uint16_t OnOffValues[] = {2 * htim1.Instance->ARR / 3, (4 * htim1.Instance->ARR) / 3};
|
|
|
|
if (ledx < WS2812_LED_COUNT) {
|
|
for (i = 0; i < 8; i++) {
|
|
// Also unmux RGB -> GRB in the index order here
|
|
ptr[i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 1] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
|
|
ptr[8 + i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 0] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
|
|
ptr[16 + i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 2] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
|
|
#if WS2812_LED_CHANNEL_COUNT == 4
|
|
ptr[24 + i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 3] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
|
|
#endif
|
|
}
|
|
} else {
|
|
// Fill with zero?
|
|
}
|
|
}
|