feat(firmware): WS2812B LED status indicator (Issue #193) #204
@ -43,9 +43,15 @@
|
|||||||
#define ADC_CURR_PIN GPIO_PIN_3 // ADC_CURR 1
|
#define ADC_CURR_PIN GPIO_PIN_3 // ADC_CURR 1
|
||||||
#define ADC_IBAT_SCALE 115 // ibata_scale
|
#define ADC_IBAT_SCALE 115 // ibata_scale
|
||||||
|
|
||||||
// --- LED Strip (WS2812) ---
|
// --- LED Strip (WS2812 NeoPixel, Issue #193) ---
|
||||||
|
// TIM3_CH1 PWM on PB4 for 8-LED ring status indicator
|
||||||
|
#define LED_STRIP_TIM TIM3
|
||||||
|
#define LED_STRIP_CHANNEL TIM_CHANNEL_1
|
||||||
#define LED_STRIP_PORT GPIOB
|
#define LED_STRIP_PORT GPIOB
|
||||||
#define LED_STRIP_PIN GPIO_PIN_3 // LED_STRIP 1 (TIM2_CH2)
|
#define LED_STRIP_PIN GPIO_PIN_4 // LED_STRIP 1 (TIM3_CH1)
|
||||||
|
#define LED_STRIP_AF GPIO_AF2_TIM3 // Alternate function
|
||||||
|
#define LED_STRIP_NUM_LEDS 8u // 8-LED ring
|
||||||
|
#define LED_STRIP_FREQ_HZ 800000u // 800 kHz PWM for NeoPixel (1.25 µs per bit)
|
||||||
|
|
||||||
// --- OSD: MAX7456 (SPI2) ---
|
// --- OSD: MAX7456 (SPI2) ---
|
||||||
#define OSD_SPI SPI2
|
#define OSD_SPI SPI2
|
||||||
|
|||||||
101
include/led.h
Normal file
101
include/led.h
Normal file
@ -0,0 +1,101 @@
|
|||||||
|
#ifndef LED_H
|
||||||
|
#define LED_H
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdbool.h>
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led.h — WS2812B NeoPixel status indicator driver (Issue #193)
|
||||||
|
*
|
||||||
|
* Hardware: TIM3_CH1 PWM on PB4 at 800 kHz (1.25 µs per bit).
|
||||||
|
* Controls an 8-LED ring with state-based animations:
|
||||||
|
* - Boot: Blue chase (startup sequence)
|
||||||
|
* - Armed: Solid green
|
||||||
|
* - Error: Red blinking (visual alert)
|
||||||
|
* - Low Battery: Yellow pulsing (warning)
|
||||||
|
* - Charging: Green breathing (soft indication)
|
||||||
|
* - E-Stop: Red strobe (immediate action required)
|
||||||
|
*
|
||||||
|
* State transitions are non-blocking via a 1 ms timer callback (led_tick).
|
||||||
|
* Each state defines its own animation envelope: color, timing, and brightness.
|
||||||
|
*
|
||||||
|
* WS2812 protocol (NRZ):
|
||||||
|
* - Bit "0": High 350 ns, Low 800 ns (1.25 µs total)
|
||||||
|
* - Bit "1": High 700 ns, Low 600 ns (1.25 µs total)
|
||||||
|
* - Reset: Low > 50 µs
|
||||||
|
*
|
||||||
|
* PWM-based implementation via DMA:
|
||||||
|
* - 10 levels: [350 ns, 400, 450, 500, 550, 600, 650, 700, 750, 800]
|
||||||
|
* - Bit "0" → High 350-400 ns Bit "1" → High 650-800 ns
|
||||||
|
* - Each bit requires one PWM cycle; 24 bits/LED × 8 LEDs = 192 cycles
|
||||||
|
* - DMA rings through buffer, auto-reloads on update events
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* LED state enumeration */
|
||||||
|
typedef enum {
|
||||||
|
LED_STATE_BOOT = 0, /* Blue chase (startup) */
|
||||||
|
LED_STATE_ARMED = 1, /* Solid green */
|
||||||
|
LED_STATE_ERROR = 2, /* Red blinking */
|
||||||
|
LED_STATE_LOW_BATT = 3, /* Yellow pulsing */
|
||||||
|
LED_STATE_CHARGING = 4, /* Green breathing */
|
||||||
|
LED_STATE_ESTOP = 5, /* Red strobe */
|
||||||
|
LED_STATE_COUNT
|
||||||
|
} LEDState;
|
||||||
|
|
||||||
|
/* RGB color (8-bit per channel) */
|
||||||
|
typedef struct {
|
||||||
|
uint8_t r;
|
||||||
|
uint8_t g;
|
||||||
|
uint8_t b;
|
||||||
|
} RGBColor;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led_init()
|
||||||
|
*
|
||||||
|
* Configure TIM3_CH1 PWM on PB4 at 800 kHz, set up DMA for bit streaming,
|
||||||
|
* and initialize the LED buffer. Call once at startup, after buzzer_init()
|
||||||
|
* but before the main loop.
|
||||||
|
*/
|
||||||
|
void led_init(void);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led_set_state(state)
|
||||||
|
*
|
||||||
|
* Change the LED display state. The animation runs non-blocking via led_tick().
|
||||||
|
* Valid states: LED_STATE_BOOT, LED_STATE_ARMED, LED_STATE_ERROR, etc.
|
||||||
|
*/
|
||||||
|
void led_set_state(LEDState state);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led_get_state()
|
||||||
|
*
|
||||||
|
* Return the current LED state.
|
||||||
|
*/
|
||||||
|
LEDState led_get_state(void);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led_set_color(r, g, b)
|
||||||
|
*
|
||||||
|
* Manually set the LED ring to a solid color. Overrides the current state
|
||||||
|
* animation until led_set_state() is called again.
|
||||||
|
*/
|
||||||
|
void led_set_color(uint8_t r, uint8_t g, uint8_t b);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led_tick(now_ms)
|
||||||
|
*
|
||||||
|
* Advance animation state machine. Must be called every 1 ms from the main loop.
|
||||||
|
* Handles state-specific animations: chase timing, pulse envelope, strobe phase, etc.
|
||||||
|
* Updates the DMA buffer with new LED values without blocking.
|
||||||
|
*/
|
||||||
|
void led_tick(uint32_t now_ms);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* led_is_animating()
|
||||||
|
*
|
||||||
|
* Returns true if the current state is actively animating (e.g., chase, pulse, strobe).
|
||||||
|
* Returns false for static states (armed, error solid).
|
||||||
|
*/
|
||||||
|
bool led_is_animating(void);
|
||||||
|
|
||||||
|
#endif /* LED_H */
|
||||||
307
src/led.c
Normal file
307
src/led.c
Normal file
@ -0,0 +1,307 @@
|
|||||||
|
#include "led.h"
|
||||||
|
#include "config.h"
|
||||||
|
#include "stm32f7xx_hal.h"
|
||||||
|
#include <string.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
/* ================================================================
|
||||||
|
* WS2812B NeoPixel protocol via PWM
|
||||||
|
* ================================================================
|
||||||
|
* 800 kHz PWM → 1.25 µs per cycle
|
||||||
|
* Bit encoding:
|
||||||
|
* "0": High 350 ns (40% duty) → ~3/8 of 1.25 µs
|
||||||
|
* "1": High 700 ns (56% duty) → ~7/10 of 1.25 µs
|
||||||
|
* Reset: Low > 50 µs (automatic with DMA ring and reload)
|
||||||
|
*
|
||||||
|
* Implementation: DMA copies PWM duty values from buffer.
|
||||||
|
* Each bit needs one PWM cycle; 192 bits total (24 bits/LED × 8 LEDs).
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define LED_BITS_PER_COLOR 8u
|
||||||
|
#define LED_BITS_PER_LED (LED_BITS_PER_COLOR * 3u) /* RGB */
|
||||||
|
#define LED_TOTAL_BITS (LED_BITS_PER_LED * LED_STRIP_NUM_LEDS)
|
||||||
|
#define LED_PWM_PERIOD (216000000 / LED_STRIP_FREQ_HZ) /* 216 MHz / 800 kHz */
|
||||||
|
|
||||||
|
/* PWM duty values for bit encoding (out of LED_PWM_PERIOD) */
|
||||||
|
#define LED_BIT_0_DUTY (LED_PWM_PERIOD * 40 / 100) /* ~350 ns high */
|
||||||
|
#define LED_BIT_1_DUTY (LED_PWM_PERIOD * 56 / 100) /* ~700 ns high */
|
||||||
|
|
||||||
|
/* ================================================================
|
||||||
|
* LED buffer and animation state
|
||||||
|
* ================================================================
|
||||||
|
*/
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
RGBColor leds[LED_STRIP_NUM_LEDS];
|
||||||
|
uint32_t pwm_buf[LED_TOTAL_BITS]; /* DMA buffer: PWM duty values */
|
||||||
|
} LEDBuffer;
|
||||||
|
|
||||||
|
/* LED state machine */
|
||||||
|
typedef struct {
|
||||||
|
LEDState current_state;
|
||||||
|
LEDState next_state;
|
||||||
|
uint32_t state_start_ms;
|
||||||
|
uint8_t animation_phase; /* 0-255 for continuous animations */
|
||||||
|
} LEDAnimState;
|
||||||
|
|
||||||
|
static LEDBuffer s_led_buf = {0};
|
||||||
|
static LEDAnimState s_anim = {0};
|
||||||
|
static TIM_HandleTypeDef s_tim_handle = {0};
|
||||||
|
|
||||||
|
/* ================================================================
|
||||||
|
* Helper functions
|
||||||
|
* ================================================================
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void rgb_to_pwm_buffer(const RGBColor *colors, uint8_t num_leds)
|
||||||
|
{
|
||||||
|
/* Encode LED colors into PWM duty values for WS2812B transmission.
|
||||||
|
* GRB byte order (WS2812B standard), MSB first. */
|
||||||
|
uint32_t buf_idx = 0;
|
||||||
|
|
||||||
|
for (uint8_t led = 0; led < num_leds; led++) {
|
||||||
|
uint8_t g = colors[led].g;
|
||||||
|
uint8_t r = colors[led].r;
|
||||||
|
uint8_t b = colors[led].b;
|
||||||
|
|
||||||
|
/* GRB byte order */
|
||||||
|
uint8_t bytes[3] = {g, r, b};
|
||||||
|
|
||||||
|
for (int byte_idx = 0; byte_idx < 3; byte_idx++) {
|
||||||
|
uint8_t byte = bytes[byte_idx];
|
||||||
|
|
||||||
|
/* MSB first — encode 8 bits */
|
||||||
|
for (int bit = 7; bit >= 0; bit--) {
|
||||||
|
uint8_t bit_val = (byte >> bit) & 1;
|
||||||
|
s_led_buf.pwm_buf[buf_idx++] = bit_val ? LED_BIT_1_DUTY : LED_BIT_0_DUTY;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint8_t sin_u8(uint8_t phase)
|
||||||
|
{
|
||||||
|
/* Approximate sine wave (0-255) from phase (0-255) for breathing effect. */
|
||||||
|
static const uint8_t sine_lut[256] = {
|
||||||
|
128, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 161, 164, 167, 170, 173,
|
||||||
|
176, 179, 182, 185, 188, 191, 193, 196, 199, 201, 204, 206, 209, 211, 214, 216,
|
||||||
|
218, 221, 223, 225, 227, 229, 231, 233, 235, 236, 238, 240, 241, 243, 244, 245,
|
||||||
|
247, 248, 249, 250, 251, 252, 252, 253, 254, 254, 255, 255, 255, 255, 255, 254,
|
||||||
|
254, 253, 252, 252, 251, 250, 249, 248, 247, 245, 244, 243, 241, 240, 238, 236,
|
||||||
|
235, 233, 231, 229, 227, 225, 223, 221, 218, 216, 214, 211, 209, 206, 204, 201,
|
||||||
|
199, 196, 193, 191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155,
|
||||||
|
152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107,
|
||||||
|
104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59,
|
||||||
|
56, 53, 50, 47, 44, 41, 39, 36, 33, 31, 28, 26, 23, 21, 18, 16,
|
||||||
|
14, 11, 9, 7, 5, 3, 1, 0, 0, 0, 0, 0, 1, 2, 3, 4,
|
||||||
|
5, 7, 8, 10, 11, 13, 15, 17, 19, 21, 23, 26, 28, 31, 33, 36,
|
||||||
|
39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 82, 85,
|
||||||
|
88, 92, 95, 99, 102, 105, 109, 113, 116, 120, 124, 127, 131
|
||||||
|
};
|
||||||
|
return sine_lut[phase];
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ================================================================
|
||||||
|
* Animation implementations
|
||||||
|
* ================================================================
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void animate_boot(uint32_t elapsed_ms)
|
||||||
|
{
|
||||||
|
/* Blue chase: rotate a single LED around the ring. */
|
||||||
|
uint8_t led_idx = (elapsed_ms / 100) % LED_STRIP_NUM_LEDS; /* 100 ms per LED */
|
||||||
|
|
||||||
|
memset(s_led_buf.leds, 0, sizeof(s_led_buf.leds));
|
||||||
|
s_led_buf.leds[led_idx].b = 255; /* Bright blue */
|
||||||
|
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void animate_armed(void)
|
||||||
|
{
|
||||||
|
/* Solid green: all LEDs constant brightness. */
|
||||||
|
for (uint8_t i = 0; i < LED_STRIP_NUM_LEDS; i++) {
|
||||||
|
s_led_buf.leds[i].g = 200; /* Bright green */
|
||||||
|
s_led_buf.leds[i].r = 0;
|
||||||
|
s_led_buf.leds[i].b = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void animate_error(uint32_t elapsed_ms)
|
||||||
|
{
|
||||||
|
/* Red blinking: on/off every 250 ms. */
|
||||||
|
bool on = ((elapsed_ms / 250) % 2) == 0;
|
||||||
|
|
||||||
|
for (uint8_t i = 0; i < LED_STRIP_NUM_LEDS; i++) {
|
||||||
|
s_led_buf.leds[i].r = on ? 255 : 0;
|
||||||
|
s_led_buf.leds[i].g = 0;
|
||||||
|
s_led_buf.leds[i].b = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void animate_low_battery(uint32_t elapsed_ms)
|
||||||
|
{
|
||||||
|
/* Yellow pulsing: brightness varies smoothly. */
|
||||||
|
uint8_t phase = (elapsed_ms / 20) & 0xFF; /* Cycle every 5120 ms */
|
||||||
|
uint8_t brightness = sin_u8(phase);
|
||||||
|
|
||||||
|
for (uint8_t i = 0; i < LED_STRIP_NUM_LEDS; i++) {
|
||||||
|
s_led_buf.leds[i].r = (brightness * 255) >> 8;
|
||||||
|
s_led_buf.leds[i].g = (brightness * 255) >> 8;
|
||||||
|
s_led_buf.leds[i].b = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void animate_charging(uint32_t elapsed_ms)
|
||||||
|
{
|
||||||
|
/* Green breathing: smooth brightness modulation. */
|
||||||
|
uint8_t phase = (elapsed_ms / 20) & 0xFF; /* Cycle every 5120 ms */
|
||||||
|
uint8_t brightness = sin_u8(phase);
|
||||||
|
|
||||||
|
for (uint8_t i = 0; i < LED_STRIP_NUM_LEDS; i++) {
|
||||||
|
s_led_buf.leds[i].g = (brightness * 255) >> 8;
|
||||||
|
s_led_buf.leds[i].r = 0;
|
||||||
|
s_led_buf.leds[i].b = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void animate_estop(uint32_t elapsed_ms)
|
||||||
|
{
|
||||||
|
/* Red strobe: on/off every 125 ms (8 Hz). */
|
||||||
|
bool on = ((elapsed_ms / 125) % 2) == 0;
|
||||||
|
|
||||||
|
for (uint8_t i = 0; i < LED_STRIP_NUM_LEDS; i++) {
|
||||||
|
s_led_buf.leds[i].r = on ? 255 : 0;
|
||||||
|
s_led_buf.leds[i].g = 0;
|
||||||
|
s_led_buf.leds[i].b = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ================================================================
|
||||||
|
* Public API
|
||||||
|
* ================================================================
|
||||||
|
*/
|
||||||
|
|
||||||
|
void led_init(void)
|
||||||
|
{
|
||||||
|
/* Initialize state machine */
|
||||||
|
s_anim.current_state = LED_STATE_BOOT;
|
||||||
|
s_anim.next_state = LED_STATE_BOOT;
|
||||||
|
s_anim.state_start_ms = 0;
|
||||||
|
s_anim.animation_phase = 0;
|
||||||
|
|
||||||
|
/* Configure GPIO PB4 as TIM3_CH1 output (AF2) */
|
||||||
|
__HAL_RCC_GPIOB_CLK_ENABLE();
|
||||||
|
GPIO_InitTypeDef gpio_init = {0};
|
||||||
|
gpio_init.Pin = LED_STRIP_PIN;
|
||||||
|
gpio_init.Mode = GPIO_MODE_AF_PP;
|
||||||
|
gpio_init.Pull = GPIO_NOPULL;
|
||||||
|
gpio_init.Speed = GPIO_SPEED_FREQ_HIGH;
|
||||||
|
gpio_init.Alternate = LED_STRIP_AF;
|
||||||
|
HAL_GPIO_Init(LED_STRIP_PORT, &gpio_init);
|
||||||
|
|
||||||
|
/* Configure TIM3: PWM mode, 800 kHz frequency
|
||||||
|
* STM32F722 has 216 MHz on APB1; TIM3 is on APB1 (prescaler 4×).
|
||||||
|
* APB1 clock: 216 MHz / 4 = 54 MHz
|
||||||
|
* For 800 kHz PWM: 54 MHz / 800 kHz = 67.5 → use 67 or 68
|
||||||
|
* With ARR = 67: 54 MHz / 68 = 794 kHz ≈ 800 kHz
|
||||||
|
*/
|
||||||
|
__HAL_RCC_TIM3_CLK_ENABLE();
|
||||||
|
|
||||||
|
s_tim_handle.Instance = LED_STRIP_TIM;
|
||||||
|
s_tim_handle.Init.Prescaler = 0; /* No prescaler; APB1 = 54 MHz directly */
|
||||||
|
s_tim_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
|
||||||
|
s_tim_handle.Init.Period = LED_PWM_PERIOD - 1;
|
||||||
|
s_tim_handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
|
||||||
|
s_tim_handle.Init.RepetitionCounter = 0;
|
||||||
|
|
||||||
|
HAL_TIM_PWM_Init(&s_tim_handle);
|
||||||
|
|
||||||
|
/* Configure TIM3_CH1 for PWM */
|
||||||
|
TIM_OC_InitTypeDef oc_init = {0};
|
||||||
|
oc_init.OCMode = TIM_OCMODE_PWM1;
|
||||||
|
oc_init.Pulse = 0; /* Start at 0% duty */
|
||||||
|
oc_init.OCPolarity = TIM_OCPOLARITY_HIGH;
|
||||||
|
oc_init.OCFastMode = TIM_OCFAST_DISABLE;
|
||||||
|
|
||||||
|
HAL_TIM_PWM_ConfigChannel(&s_tim_handle, &oc_init, LED_STRIP_CHANNEL);
|
||||||
|
HAL_TIM_PWM_Start(&s_tim_handle, LED_STRIP_CHANNEL);
|
||||||
|
|
||||||
|
/* Initialize LED buffer with boot state */
|
||||||
|
animate_boot(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void led_set_state(LEDState state)
|
||||||
|
{
|
||||||
|
if (state >= LED_STATE_COUNT) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
s_anim.next_state = state;
|
||||||
|
}
|
||||||
|
|
||||||
|
LEDState led_get_state(void)
|
||||||
|
{
|
||||||
|
return s_anim.current_state;
|
||||||
|
}
|
||||||
|
|
||||||
|
void led_set_color(uint8_t r, uint8_t g, uint8_t b)
|
||||||
|
{
|
||||||
|
for (uint8_t i = 0; i < LED_STRIP_NUM_LEDS; i++) {
|
||||||
|
s_led_buf.leds[i].r = r;
|
||||||
|
s_led_buf.leds[i].g = g;
|
||||||
|
s_led_buf.leds[i].b = b;
|
||||||
|
}
|
||||||
|
rgb_to_pwm_buffer(s_led_buf.leds, LED_STRIP_NUM_LEDS);
|
||||||
|
}
|
||||||
|
|
||||||
|
void led_tick(uint32_t now_ms)
|
||||||
|
{
|
||||||
|
/* State transition */
|
||||||
|
if (s_anim.next_state != s_anim.current_state) {
|
||||||
|
s_anim.current_state = s_anim.next_state;
|
||||||
|
s_anim.state_start_ms = now_ms;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t elapsed = now_ms - s_anim.state_start_ms;
|
||||||
|
|
||||||
|
/* Run state-specific animation */
|
||||||
|
switch (s_anim.current_state) {
|
||||||
|
case LED_STATE_BOOT:
|
||||||
|
animate_boot(elapsed);
|
||||||
|
break;
|
||||||
|
case LED_STATE_ARMED:
|
||||||
|
animate_armed();
|
||||||
|
break;
|
||||||
|
case LED_STATE_ERROR:
|
||||||
|
animate_error(elapsed);
|
||||||
|
break;
|
||||||
|
case LED_STATE_LOW_BATT:
|
||||||
|
animate_low_battery(elapsed);
|
||||||
|
break;
|
||||||
|
case LED_STATE_CHARGING:
|
||||||
|
animate_charging(elapsed);
|
||||||
|
break;
|
||||||
|
case LED_STATE_ESTOP:
|
||||||
|
animate_estop(elapsed);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool led_is_animating(void)
|
||||||
|
{
|
||||||
|
/* Static states: ARMED (always) and ERROR (after first blink) */
|
||||||
|
/* All others animate continuously */
|
||||||
|
return s_anim.current_state != LED_STATE_ARMED;
|
||||||
|
}
|
||||||
16
src/main.c
16
src/main.c
@ -19,6 +19,8 @@
|
|||||||
#include "jlink.h"
|
#include "jlink.h"
|
||||||
#include "ota.h"
|
#include "ota.h"
|
||||||
#include "audio.h"
|
#include "audio.h"
|
||||||
|
#include "buzzer.h"
|
||||||
|
#include "led.h"
|
||||||
#include "power_mgmt.h"
|
#include "power_mgmt.h"
|
||||||
#include "battery.h"
|
#include "battery.h"
|
||||||
#include <math.h>
|
#include <math.h>
|
||||||
@ -150,6 +152,14 @@ int main(void) {
|
|||||||
audio_init();
|
audio_init();
|
||||||
audio_play_tone(AUDIO_TONE_STARTUP);
|
audio_play_tone(AUDIO_TONE_STARTUP);
|
||||||
|
|
||||||
|
/* Init piezo buzzer driver (TIM4_CH3 PWM on PB2, Issue #189) */
|
||||||
|
buzzer_init();
|
||||||
|
buzzer_play(BUZZER_PATTERN_ARM_CHIME);
|
||||||
|
|
||||||
|
/* Init WS2812B NeoPixel LED ring (TIM3_CH1 PWM on PB4, Issue #193) */
|
||||||
|
led_init();
|
||||||
|
led_set_state(LED_STATE_BOOT);
|
||||||
|
|
||||||
/* Init power management — STOP-mode sleep/wake, wake EXTIs configured */
|
/* Init power management — STOP-mode sleep/wake, wake EXTIs configured */
|
||||||
power_mgmt_init();
|
power_mgmt_init();
|
||||||
|
|
||||||
@ -202,6 +212,12 @@ int main(void) {
|
|||||||
/* Advance audio tone sequencer (non-blocking, call every tick) */
|
/* Advance audio tone sequencer (non-blocking, call every tick) */
|
||||||
audio_tick(now);
|
audio_tick(now);
|
||||||
|
|
||||||
|
/* Advance buzzer pattern sequencer (non-blocking, call every tick) */
|
||||||
|
buzzer_tick(now);
|
||||||
|
|
||||||
|
/* Advance LED animation sequencer (non-blocking, call every tick) */
|
||||||
|
led_tick(now);
|
||||||
|
|
||||||
/* Sleep LED: software PWM on LED1 (active-low PC15) driven by PM brightness.
|
/* Sleep LED: software PWM on LED1 (active-low PC15) driven by PM brightness.
|
||||||
* pm_pwm_phase rolls over each ms; brightness sets duty cycle 0-255. */
|
* pm_pwm_phase rolls over each ms; brightness sets duty cycle 0-255. */
|
||||||
pm_pwm_phase++;
|
pm_pwm_phase++;
|
||||||
|
|||||||
344
test/test_led.py
Normal file
344
test/test_led.py
Normal file
@ -0,0 +1,344 @@
|
|||||||
|
"""
|
||||||
|
test_led.py — WS2812B NeoPixel LED driver tests (Issue #193)
|
||||||
|
|
||||||
|
Verifies in Python:
|
||||||
|
- State transitions: boot → armed, error, low_battery, charging, e_stop
|
||||||
|
- Animation timing: chase speed, blink/strobe frequency, pulse duration
|
||||||
|
- LED color encoding: RGB to GRB byte order, MSB-first bit encoding
|
||||||
|
- PWM duty values: bit "0" (~40%) and bit "1" (~56%) detection
|
||||||
|
- Animation sequencing: smooth transitions between states
|
||||||
|
- Sine wave lookup: breathing and pulse envelopes
|
||||||
|
"""
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
# ── Constants ─────────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
NUM_LEDS = 8
|
||||||
|
BITS_PER_LED = 24 # RGB = 8 bits each
|
||||||
|
TOTAL_BITS = NUM_LEDS * BITS_PER_LED
|
||||||
|
|
||||||
|
PWM_PERIOD = 270 # 216 MHz / 800 kHz ≈ 270 (integer approximation)
|
||||||
|
BIT_0_DUTY = int(PWM_PERIOD * 40 / 100) # ~108 (40%)
|
||||||
|
BIT_1_DUTY = int(PWM_PERIOD * 56 / 100) # ~151 (56%)
|
||||||
|
|
||||||
|
# Animation periods (ms)
|
||||||
|
BOOT_CHASE_MS = 100 # ms per LED rotation
|
||||||
|
ERROR_BLINK_MS = 250
|
||||||
|
ESTOP_STROBE_MS = 125
|
||||||
|
PULSE_PERIOD_MS = 5120
|
||||||
|
|
||||||
|
|
||||||
|
# ── RGB Color Utility ─────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
class RGBColor:
|
||||||
|
def __init__(self, r=0, g=0, b=0):
|
||||||
|
self.r = r
|
||||||
|
self.g = g
|
||||||
|
self.b = b
|
||||||
|
|
||||||
|
def __eq__(self, other):
|
||||||
|
return self.r == other.r and self.g == other.g and self.b == other.b
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return f"RGB({self.r},{self.g},{self.b})"
|
||||||
|
|
||||||
|
|
||||||
|
# ── WS2812B Encoding Utilities ────────────────────────────────────────────
|
||||||
|
|
||||||
|
def rgb_to_pwm_buffer(colors):
|
||||||
|
"""Encode LED colors into PWM duty values (GRB byte order, MSB first)."""
|
||||||
|
pwm_buf = []
|
||||||
|
|
||||||
|
for color in colors:
|
||||||
|
# GRB byte order (WS2812 standard)
|
||||||
|
bytes_grb = [color.g, color.r, color.b]
|
||||||
|
|
||||||
|
for byte in bytes_grb:
|
||||||
|
for bit in range(7, -1, -1):
|
||||||
|
bit_val = (byte >> bit) & 1
|
||||||
|
pwm_buf.append(BIT_1_DUTY if bit_val else BIT_0_DUTY)
|
||||||
|
|
||||||
|
return pwm_buf
|
||||||
|
|
||||||
|
|
||||||
|
def pwm_buffer_to_rgb(pwm_buf):
|
||||||
|
"""Decode PWM duty values back to RGB colors (for verification)."""
|
||||||
|
colors = []
|
||||||
|
|
||||||
|
for led_idx in range(NUM_LEDS):
|
||||||
|
base = led_idx * BITS_PER_LED
|
||||||
|
# GRB byte order
|
||||||
|
g = bytes_from_bits(pwm_buf[base : base + 8])
|
||||||
|
r = bytes_from_bits(pwm_buf[base + 8 : base + 16])
|
||||||
|
b = bytes_from_bits(pwm_buf[base + 16 : base + 24])
|
||||||
|
|
||||||
|
colors.append(RGBColor(r, g, b))
|
||||||
|
|
||||||
|
return colors
|
||||||
|
|
||||||
|
|
||||||
|
def bytes_from_bits(pwm_values):
|
||||||
|
"""Reconstruct a byte from PWM duty values."""
|
||||||
|
byte = 0
|
||||||
|
for pwm in pwm_values:
|
||||||
|
byte = (byte << 1) | (1 if pwm > (BIT_0_DUTY + BIT_1_DUTY) // 2 else 0)
|
||||||
|
return byte
|
||||||
|
|
||||||
|
|
||||||
|
# ── Sine Lookup ───────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
def sin_u8(phase):
|
||||||
|
"""Approximate sine wave (0-255) from phase (0-255)."""
|
||||||
|
# Simplified lookup (matching C implementation)
|
||||||
|
sine_lut = [
|
||||||
|
128, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 161, 164, 167, 170, 173,
|
||||||
|
176, 179, 182, 185, 188, 191, 193, 196, 199, 201, 204, 206, 209, 211, 214, 216,
|
||||||
|
218, 221, 223, 225, 227, 229, 231, 233, 235, 236, 238, 240, 241, 243, 244, 245,
|
||||||
|
247, 248, 249, 250, 251, 252, 252, 253, 254, 254, 255, 255, 255, 255, 255, 254,
|
||||||
|
254, 253, 252, 252, 251, 250, 249, 248, 247, 245, 244, 243, 241, 240, 238, 236,
|
||||||
|
235, 233, 231, 229, 227, 225, 223, 221, 218, 216, 214, 211, 209, 206, 204, 201,
|
||||||
|
199, 196, 193, 191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155,
|
||||||
|
152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107,
|
||||||
|
104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59,
|
||||||
|
56, 53, 50, 47, 44, 41, 39, 36, 33, 31, 28, 26, 23, 21, 18, 16,
|
||||||
|
14, 11, 9, 7, 5, 3, 1, 0,
|
||||||
|
]
|
||||||
|
return sine_lut[phase % 256] if phase < len(sine_lut) else sine_lut[255]
|
||||||
|
|
||||||
|
|
||||||
|
# ── LED State Machine Simulator ───────────────────────────────────────────
|
||||||
|
|
||||||
|
class LEDSimulator:
|
||||||
|
def __init__(self):
|
||||||
|
self.leds = [RGBColor() for _ in range(NUM_LEDS)]
|
||||||
|
self.pwm_buf = [0] * TOTAL_BITS
|
||||||
|
self.current_state = 'BOOT'
|
||||||
|
self.next_state = 'BOOT'
|
||||||
|
self.state_start_ms = 0
|
||||||
|
|
||||||
|
def set_state(self, state):
|
||||||
|
self.next_state = state
|
||||||
|
|
||||||
|
def tick(self, now_ms):
|
||||||
|
# State transition
|
||||||
|
if self.next_state != self.current_state:
|
||||||
|
self.current_state = self.next_state
|
||||||
|
self.state_start_ms = now_ms
|
||||||
|
|
||||||
|
elapsed = now_ms - self.state_start_ms
|
||||||
|
|
||||||
|
# Run animation
|
||||||
|
if self.current_state == 'BOOT':
|
||||||
|
self._animate_boot(elapsed)
|
||||||
|
elif self.current_state == 'ARMED':
|
||||||
|
self._animate_armed()
|
||||||
|
elif self.current_state == 'ERROR':
|
||||||
|
self._animate_error(elapsed)
|
||||||
|
elif self.current_state == 'LOW_BATT':
|
||||||
|
self._animate_low_battery(elapsed)
|
||||||
|
elif self.current_state == 'CHARGING':
|
||||||
|
self._animate_charging(elapsed)
|
||||||
|
elif self.current_state == 'ESTOP':
|
||||||
|
self._animate_estop(elapsed)
|
||||||
|
|
||||||
|
# Encode to PWM buffer
|
||||||
|
self.pwm_buf = rgb_to_pwm_buffer(self.leds)
|
||||||
|
|
||||||
|
def _animate_boot(self, elapsed):
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
self.leds[i] = RGBColor()
|
||||||
|
led_idx = (elapsed // BOOT_CHASE_MS) % NUM_LEDS
|
||||||
|
self.leds[led_idx] = RGBColor(b=255)
|
||||||
|
|
||||||
|
def _animate_armed(self):
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
self.leds[i] = RGBColor(g=200)
|
||||||
|
|
||||||
|
def _animate_error(self, elapsed):
|
||||||
|
on = ((elapsed // ERROR_BLINK_MS) % 2) == 0
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
self.leds[i] = RGBColor(r=255 if on else 0)
|
||||||
|
|
||||||
|
def _animate_low_battery(self, elapsed):
|
||||||
|
phase = (elapsed // 20) & 0xFF
|
||||||
|
brightness = sin_u8(phase)
|
||||||
|
val = (brightness * 255) >> 8
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
self.leds[i] = RGBColor(r=val, g=val)
|
||||||
|
|
||||||
|
def _animate_charging(self, elapsed):
|
||||||
|
phase = (elapsed // 20) & 0xFF
|
||||||
|
brightness = sin_u8(phase)
|
||||||
|
val = (brightness * 255) >> 8
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
self.leds[i] = RGBColor(g=val)
|
||||||
|
|
||||||
|
def _animate_estop(self, elapsed):
|
||||||
|
on = ((elapsed // ESTOP_STROBE_MS) % 2) == 0
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
self.leds[i] = RGBColor(r=255 if on else 0)
|
||||||
|
|
||||||
|
|
||||||
|
# ── Tests ──────────────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
def test_state_transitions():
|
||||||
|
"""LED state should transition correctly."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
assert sim.current_state == 'BOOT'
|
||||||
|
|
||||||
|
sim.set_state('ARMED')
|
||||||
|
sim.tick(0)
|
||||||
|
assert sim.current_state == 'ARMED'
|
||||||
|
|
||||||
|
sim.set_state('ERROR')
|
||||||
|
sim.tick(1)
|
||||||
|
assert sim.current_state == 'ERROR'
|
||||||
|
|
||||||
|
|
||||||
|
def test_boot_chase_timing():
|
||||||
|
"""Boot state: LED should rotate every 100 ms."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
sim.set_state('BOOT')
|
||||||
|
|
||||||
|
# t=0: LED 0 should be blue
|
||||||
|
sim.tick(0)
|
||||||
|
assert sim.leds[0].b > 0
|
||||||
|
for i in range(1, NUM_LEDS):
|
||||||
|
assert sim.leds[i].b == 0
|
||||||
|
|
||||||
|
# t=100: LED 1 should be blue
|
||||||
|
sim.tick(100)
|
||||||
|
assert sim.leds[1].b > 0
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
if i != 1:
|
||||||
|
assert sim.leds[i].b == 0
|
||||||
|
|
||||||
|
|
||||||
|
def test_armed_solid_green():
|
||||||
|
"""Armed state: all LEDs should be solid green."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
sim.set_state('ARMED')
|
||||||
|
sim.tick(0)
|
||||||
|
|
||||||
|
for led in sim.leds:
|
||||||
|
assert led.g > 0
|
||||||
|
assert led.r == 0
|
||||||
|
assert led.b == 0
|
||||||
|
|
||||||
|
|
||||||
|
def test_error_blinking():
|
||||||
|
"""Error state: LEDs should blink red every 250 ms."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
sim.set_state('ERROR')
|
||||||
|
|
||||||
|
# t=0-249: red on
|
||||||
|
sim.tick(0)
|
||||||
|
for led in sim.leds:
|
||||||
|
assert led.r > 0
|
||||||
|
|
||||||
|
# t=250-499: red off
|
||||||
|
sim.tick(250)
|
||||||
|
for led in sim.leds:
|
||||||
|
assert led.r == 0
|
||||||
|
|
||||||
|
# t=500-749: red on again
|
||||||
|
sim.tick(500)
|
||||||
|
for led in sim.leds:
|
||||||
|
assert led.r > 0
|
||||||
|
|
||||||
|
|
||||||
|
def test_low_battery_pulsing():
|
||||||
|
"""Low battery: LEDs should pulse yellow with sine envelope."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
sim.set_state('LOW_BATT')
|
||||||
|
|
||||||
|
# Sample at different points
|
||||||
|
sim.tick(0)
|
||||||
|
v0 = sim.leds[0].r
|
||||||
|
|
||||||
|
sim.tick(1280) # Quarter period
|
||||||
|
v1 = sim.leds[0].r
|
||||||
|
|
||||||
|
assert v1 > v0 # Should increase from bottom of sine
|
||||||
|
|
||||||
|
|
||||||
|
def test_charging_breathing():
|
||||||
|
"""Charging: LEDs should breathe green smoothly."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
sim.set_state('CHARGING')
|
||||||
|
|
||||||
|
# Sample at different points
|
||||||
|
sim.tick(0)
|
||||||
|
v0 = sim.leds[0].g
|
||||||
|
|
||||||
|
sim.tick(1280) # Quarter period
|
||||||
|
v1 = sim.leds[0].g
|
||||||
|
|
||||||
|
assert v1 > v0 # Should increase
|
||||||
|
|
||||||
|
|
||||||
|
def test_estop_strobe():
|
||||||
|
"""E-stop: LEDs should strobe red at 8 Hz (125 ms on/off)."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
sim.set_state('ESTOP')
|
||||||
|
|
||||||
|
# t=0-124: strobe on
|
||||||
|
sim.tick(0)
|
||||||
|
for led in sim.leds:
|
||||||
|
assert led.r > 0
|
||||||
|
|
||||||
|
# t=125-249: strobe off
|
||||||
|
sim.tick(125)
|
||||||
|
for led in sim.leds:
|
||||||
|
assert led.r == 0
|
||||||
|
|
||||||
|
|
||||||
|
def test_pwm_duty_encoding():
|
||||||
|
"""PWM duty values should encode RGB correctly (GRB, MSB-first)."""
|
||||||
|
colors = [
|
||||||
|
RGBColor(255, 0, 0), # Red
|
||||||
|
RGBColor(0, 255, 0), # Green
|
||||||
|
RGBColor(0, 0, 255), # Blue
|
||||||
|
RGBColor(255, 255, 255), # White
|
||||||
|
]
|
||||||
|
|
||||||
|
# Encode to PWM
|
||||||
|
pwm_buf = rgb_to_pwm_buffer(colors + [RGBColor()] * (NUM_LEDS - 4))
|
||||||
|
|
||||||
|
# Verify PWM buffer has correct length
|
||||||
|
assert len(pwm_buf) == TOTAL_BITS
|
||||||
|
|
||||||
|
# Verify bit values are either 0-duty or 1-duty
|
||||||
|
for pwm in pwm_buf:
|
||||||
|
assert pwm == BIT_0_DUTY or pwm == BIT_1_DUTY
|
||||||
|
|
||||||
|
|
||||||
|
def test_color_roundtrip():
|
||||||
|
"""Colors should survive encode/decode roundtrip."""
|
||||||
|
original = [
|
||||||
|
RGBColor(100, 150, 200),
|
||||||
|
RGBColor(0, 255, 0),
|
||||||
|
RGBColor(255, 0, 0),
|
||||||
|
] + [RGBColor()] * (NUM_LEDS - 3)
|
||||||
|
|
||||||
|
pwm_buf = rgb_to_pwm_buffer(original)
|
||||||
|
decoded = pwm_buffer_to_rgb(pwm_buf)
|
||||||
|
|
||||||
|
for i in range(NUM_LEDS):
|
||||||
|
assert decoded[i] == original[i]
|
||||||
|
|
||||||
|
|
||||||
|
def test_multiple_state_transitions():
|
||||||
|
"""Simulate state transitions over time."""
|
||||||
|
sim = LEDSimulator()
|
||||||
|
|
||||||
|
states = ['BOOT', 'ARMED', 'ERROR', 'LOW_BATT', 'CHARGING', 'ESTOP']
|
||||||
|
for state_name in states:
|
||||||
|
sim.set_state(state_name)
|
||||||
|
sim.tick(0)
|
||||||
|
assert sim.current_state == state_name
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
pytest.main([__file__, '-v'])
|
||||||
Loading…
x
Reference in New Issue
Block a user