Compare commits
2 Commits
6dbbbb9adc
...
fbca191bae
| Author | SHA1 | Date | |
|---|---|---|---|
| fbca191bae | |||
| aedb8771ad |
@ -43,9 +43,15 @@
|
||||
#define ADC_CURR_PIN GPIO_PIN_3 // ADC_CURR 1
|
||||
#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_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) ---
|
||||
#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 "ota.h"
|
||||
#include "audio.h"
|
||||
#include "buzzer.h"
|
||||
#include "led.h"
|
||||
#include "power_mgmt.h"
|
||||
#include "battery.h"
|
||||
#include <math.h>
|
||||
@ -150,6 +152,14 @@ int main(void) {
|
||||
audio_init();
|
||||
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 */
|
||||
power_mgmt_init();
|
||||
|
||||
@ -202,6 +212,12 @@ int main(void) {
|
||||
/* Advance audio tone sequencer (non-blocking, call every tick) */
|
||||
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.
|
||||
* pm_pwm_phase rolls over each ms; brightness sets duty cycle 0-255. */
|
||||
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'])
|
||||
@ -47,6 +47,9 @@ import { SettingsPanel } from './components/SettingsPanel.jsx';
|
||||
// Camera viewer (issue #177)
|
||||
import { CameraViewer } from './components/CameraViewer.jsx';
|
||||
|
||||
// Event log (issue #192)
|
||||
import { EventLog } from './components/EventLog.jsx';
|
||||
|
||||
const TAB_GROUPS = [
|
||||
{
|
||||
label: 'SOCIAL',
|
||||
@ -80,6 +83,13 @@ const TAB_GROUPS = [
|
||||
{ id: 'missions', label: 'Missions' },
|
||||
],
|
||||
},
|
||||
{
|
||||
label: 'MONITORING',
|
||||
color: 'text-yellow-600',
|
||||
tabs: [
|
||||
{ id: 'eventlog', label: 'Events' },
|
||||
],
|
||||
},
|
||||
{
|
||||
label: 'CONFIG',
|
||||
color: 'text-purple-600',
|
||||
@ -200,7 +210,7 @@ export default function App() {
|
||||
</nav>
|
||||
|
||||
{/* ── Content ── */}
|
||||
<main className="flex-1 overflow-y-auto p-4">
|
||||
<main className={`flex-1 ${activeTab === 'eventlog' ? 'flex flex-col' : 'overflow-y-auto'} p-4`}>
|
||||
{activeTab === 'status' && <StatusPanel subscribe={subscribe} />}
|
||||
{activeTab === 'faces' && <FaceGallery subscribe={subscribe} callService={callService} />}
|
||||
{activeTab === 'conversation' && <ConversationLog subscribe={subscribe} />}
|
||||
@ -218,6 +228,8 @@ export default function App() {
|
||||
{activeTab === 'fleet' && <FleetPanel />}
|
||||
{activeTab === 'missions' && <MissionPlanner />}
|
||||
|
||||
{activeTab === 'eventlog' && <EventLog subscribe={subscribe} />}
|
||||
|
||||
{activeTab === 'settings' && <SettingsPanel subscribe={subscribe} callService={callService} connected={connected} wsUrl={wsUrl} />}
|
||||
</main>
|
||||
|
||||
|
||||
290
ui/social-bot/src/components/EventLog.jsx
Normal file
290
ui/social-bot/src/components/EventLog.jsx
Normal file
@ -0,0 +1,290 @@
|
||||
/**
|
||||
* EventLog.jsx — Robot event log viewer
|
||||
*
|
||||
* Displays timestamped, color-coded event cards from:
|
||||
* /saltybot/emergency (emergency events)
|
||||
* /saltybot/docking_status (docking state changes)
|
||||
* /diagnostics (system diagnostics)
|
||||
*
|
||||
* Features:
|
||||
* - Real-time event streaming
|
||||
* - Color-coded by event type (red=emergency, blue=docking, cyan=diagnostics)
|
||||
* - Filter by type
|
||||
* - Auto-scroll to latest event
|
||||
* - Configurable max event history (default 200)
|
||||
*/
|
||||
|
||||
import { useEffect, useRef, useState } from 'react';
|
||||
|
||||
const EVENT_TYPES = {
|
||||
EMERGENCY: 'emergency',
|
||||
DOCKING: 'docking',
|
||||
DIAGNOSTIC: 'diagnostic',
|
||||
};
|
||||
|
||||
const EVENT_COLORS = {
|
||||
emergency: { bg: 'bg-red-950', border: 'border-red-800', text: 'text-red-400', label: 'Emergency' },
|
||||
docking: { bg: 'bg-blue-950', border: 'border-blue-800', text: 'text-blue-400', label: 'Docking' },
|
||||
diagnostic: { bg: 'bg-cyan-950', border: 'border-cyan-800', text: 'text-cyan-400', label: 'Diagnostic' },
|
||||
};
|
||||
|
||||
const MAX_EVENTS = 200;
|
||||
|
||||
function formatTimestamp(ts) {
|
||||
const date = new Date(ts);
|
||||
return date.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
|
||||
}
|
||||
|
||||
function EventCard({ event, colors }) {
|
||||
return (
|
||||
<div className={`rounded border ${colors.border} ${colors.bg} p-3 text-sm space-y-1`}>
|
||||
<div className="flex justify-between items-start gap-2">
|
||||
<span className={`font-bold tracking-widest text-xs ${colors.text}`}>
|
||||
{colors.label}
|
||||
</span>
|
||||
<span className="text-gray-600 text-xs flex-shrink-0">
|
||||
{formatTimestamp(event.timestamp)}
|
||||
</span>
|
||||
</div>
|
||||
<div className="text-gray-300 break-words">
|
||||
{event.message}
|
||||
</div>
|
||||
{event.details && (
|
||||
<div className="text-gray-500 text-xs font-mono pt-1 border-t border-gray-800">
|
||||
{typeof event.details === 'string' ? (
|
||||
event.details
|
||||
) : (
|
||||
<pre className="overflow-x-auto">{JSON.stringify(event.details, null, 2)}</pre>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export function EventLog({ subscribe }) {
|
||||
const [events, setEvents] = useState([]);
|
||||
const [selectedTypes, setSelectedTypes] = useState(new Set(Object.values(EVENT_TYPES)));
|
||||
const [expandedEventId, setExpandedEventId] = useState(null);
|
||||
const scrollRef = useRef(null);
|
||||
const eventIdRef = useRef(0);
|
||||
|
||||
// Auto-scroll to bottom when new events arrive
|
||||
useEffect(() => {
|
||||
if (scrollRef.current && events.length > 0) {
|
||||
setTimeout(() => {
|
||||
scrollRef.current?.scrollIntoView({ behavior: 'smooth', block: 'end' });
|
||||
}, 0);
|
||||
}
|
||||
}, [events.length]);
|
||||
|
||||
// Subscribe to emergency events
|
||||
useEffect(() => {
|
||||
const unsub = subscribe(
|
||||
'/saltybot/emergency',
|
||||
'std_msgs/String',
|
||||
(msg) => {
|
||||
try {
|
||||
const data = typeof msg.data === 'string' ? JSON.parse(msg.data) : msg.data;
|
||||
setEvents((prev) => [
|
||||
...prev,
|
||||
{
|
||||
id: ++eventIdRef.current,
|
||||
type: EVENT_TYPES.EMERGENCY,
|
||||
timestamp: Date.now(),
|
||||
message: data.message || data.status || JSON.stringify(data),
|
||||
details: data,
|
||||
},
|
||||
].slice(-MAX_EVENTS));
|
||||
} catch (e) {
|
||||
setEvents((prev) => [
|
||||
...prev,
|
||||
{
|
||||
id: ++eventIdRef.current,
|
||||
type: EVENT_TYPES.EMERGENCY,
|
||||
timestamp: Date.now(),
|
||||
message: msg.data || 'Unknown emergency event',
|
||||
details: null,
|
||||
},
|
||||
].slice(-MAX_EVENTS));
|
||||
}
|
||||
}
|
||||
);
|
||||
return unsub;
|
||||
}, [subscribe]);
|
||||
|
||||
// Subscribe to docking status
|
||||
useEffect(() => {
|
||||
const unsub = subscribe(
|
||||
'/saltybot/docking_status',
|
||||
'std_msgs/String',
|
||||
(msg) => {
|
||||
try {
|
||||
const data = typeof msg.data === 'string' ? JSON.parse(msg.data) : msg.data;
|
||||
const statusMsg = data.status || data.state || data.message || JSON.stringify(data);
|
||||
setEvents((prev) => [
|
||||
...prev,
|
||||
{
|
||||
id: ++eventIdRef.current,
|
||||
type: EVENT_TYPES.DOCKING,
|
||||
timestamp: Date.now(),
|
||||
message: `Docking Status: ${statusMsg}`,
|
||||
details: data,
|
||||
},
|
||||
].slice(-MAX_EVENTS));
|
||||
} catch (e) {
|
||||
setEvents((prev) => [
|
||||
...prev,
|
||||
{
|
||||
id: ++eventIdRef.current,
|
||||
type: EVENT_TYPES.DOCKING,
|
||||
timestamp: Date.now(),
|
||||
message: `Docking Status: ${msg.data || 'Unknown'}`,
|
||||
details: null,
|
||||
},
|
||||
].slice(-MAX_EVENTS));
|
||||
}
|
||||
}
|
||||
);
|
||||
return unsub;
|
||||
}, [subscribe]);
|
||||
|
||||
// Subscribe to diagnostics
|
||||
useEffect(() => {
|
||||
const unsub = subscribe(
|
||||
'/diagnostics',
|
||||
'diagnostic_msgs/DiagnosticArray',
|
||||
(msg) => {
|
||||
try {
|
||||
for (const status of msg.status ?? []) {
|
||||
if (status.level > 0) {
|
||||
// Only log warnings and errors
|
||||
const kv = {};
|
||||
for (const pair of status.values ?? []) {
|
||||
kv[pair.key] = pair.value;
|
||||
}
|
||||
setEvents((prev) => [
|
||||
...prev,
|
||||
{
|
||||
id: ++eventIdRef.current,
|
||||
type: EVENT_TYPES.DIAGNOSTIC,
|
||||
timestamp: Date.now(),
|
||||
message: `${status.name}: ${status.message}`,
|
||||
details: kv,
|
||||
},
|
||||
].slice(-MAX_EVENTS));
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
// Ignore parsing errors
|
||||
}
|
||||
}
|
||||
);
|
||||
return unsub;
|
||||
}, [subscribe]);
|
||||
|
||||
const filteredEvents = events.filter((event) => selectedTypes.has(event.type));
|
||||
|
||||
const toggleEventType = (type) => {
|
||||
setSelectedTypes((prev) => {
|
||||
const next = new Set(prev);
|
||||
if (next.has(type)) {
|
||||
next.delete(type);
|
||||
} else {
|
||||
next.add(type);
|
||||
}
|
||||
return next;
|
||||
});
|
||||
};
|
||||
|
||||
const clearEvents = () => {
|
||||
setEvents([]);
|
||||
eventIdRef.current = 0;
|
||||
};
|
||||
|
||||
return (
|
||||
<div className="flex flex-col h-full space-y-3">
|
||||
{/* Controls */}
|
||||
<div className="bg-gray-950 rounded-lg border border-cyan-950 p-4 space-y-3">
|
||||
<div className="flex justify-between items-center flex-wrap gap-2">
|
||||
<div className="text-cyan-700 text-xs font-bold tracking-widest">
|
||||
EVENT LOG
|
||||
</div>
|
||||
<div className="text-gray-600 text-xs">
|
||||
{filteredEvents.length} of {events.length} events
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* Filter buttons */}
|
||||
<div className="flex gap-2 flex-wrap">
|
||||
{Object.entries(EVENT_COLORS).map(([typeKey, colors]) => (
|
||||
<button
|
||||
key={typeKey}
|
||||
onClick={() => toggleEventType(typeKey)}
|
||||
className={`px-3 py-1.5 text-xs font-bold tracking-widest rounded border transition-colors ${
|
||||
selectedTypes.has(typeKey)
|
||||
? `${colors.bg} ${colors.border} ${colors.text}`
|
||||
: 'bg-gray-900 border-gray-800 text-gray-600 hover:text-gray-400'
|
||||
}`}
|
||||
>
|
||||
{colors.label}
|
||||
</button>
|
||||
))}
|
||||
<button
|
||||
onClick={clearEvents}
|
||||
className="ml-auto px-3 py-1.5 text-xs font-bold tracking-widest rounded border border-gray-800 text-gray-600 hover:text-red-400 hover:border-red-800 transition-colors"
|
||||
>
|
||||
CLEAR
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* Event list */}
|
||||
<div className="flex-1 overflow-y-auto space-y-2 pr-2">
|
||||
{filteredEvents.length > 0 ? (
|
||||
<>
|
||||
{filteredEvents.map((event) => {
|
||||
const colors = EVENT_COLORS[event.type];
|
||||
return (
|
||||
<div
|
||||
key={event.id}
|
||||
onClick={() =>
|
||||
setExpandedEventId(expandedEventId === event.id ? null : event.id)
|
||||
}
|
||||
className="cursor-pointer hover:opacity-80 transition-opacity"
|
||||
>
|
||||
<EventCard event={event} colors={colors} />
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
<div ref={scrollRef} />
|
||||
</>
|
||||
) : (
|
||||
<div className="text-center py-12 text-gray-600 text-sm">
|
||||
{events.length === 0 ? (
|
||||
<>
|
||||
<div>No events yet</div>
|
||||
<div className="text-xs text-gray-700 mt-2">
|
||||
Waiting for events from emergency, docking, and diagnostics topics…
|
||||
</div>
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<div>No events match selected filter</div>
|
||||
<div className="text-xs text-gray-700 mt-2">
|
||||
{events.length} events available, adjust filters above
|
||||
</div>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{/* Stats footer */}
|
||||
<div className="bg-gray-950 rounded border border-gray-800 p-2 text-xs text-gray-600 flex justify-between">
|
||||
<span>Displaying {filteredEvents.length} / {events.length} events</span>
|
||||
<span className="text-gray-700">Max capacity: {MAX_EVENTS}</span>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user