gronod/squeezelite-esp32
1
0
Fork 2
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2026-03-21 13:59:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
refactoring
squeezelite-esp32/components/led_strip/led_vu.c

390 lines
12 KiB
C
Raw Permalink Blame History

/*
* Control of LED strip within squeezelite-esp32
*
* (c) Wizmo 2021
*
* Loosely based on code by
* Chuck Rohs 2020, chuck@zethus.ca
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*
* ToDo:
* Driver does support other led device. Maybe look at supporting in future.
* The VU refresh rate has been decreaced (100->75) to optimize animation of spin dial. Could make
* configurable like text scrolling (or use the same value)
* Artwork function, but not released as very buggy and not really practical
*/
#include <ctype.h>
#include <math.h>
#include "esp_log.h"
#include "globdefs.h"
#include "monitor.h"
#include "led_strip.h"
#include "Config.h"
#include "accessors.h"
#include "led_vu.h"
static const char* TAG = "led_vu";
static void (*battery_handler_chain)(float value, int cells);
static void battery_svc(float value, int cells);
static int battery_status = 0;
#define LED_VU_STACK_SIZE (3 * 1024)
#define LED_VU_PEAK_HOLD 6U
#define LED_VU_DEFAULT_GPIO 22
#define LED_VU_DEFAULT_LENGTH 19
#define LED_VU_MAX_LENGTH 255
#define LED_VU_STATUS_GREEN 75
#define LED_VU_STATUS_RED 25
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct led_strip_t* led_display = NULL;
static EXT_RAM_ATTR struct led_strip_t led_strip_config;
static EXT_RAM_ATTR struct {
int gpio;
int length;
int vu_length;
int vu_start_l;
int vu_start_r;
int vu_status;
} strip;
static int led_addr(int pos) {
if(pos < 0) return pos + strip.length;
if(pos >= strip.length) return pos - strip.length;
return pos;
}
static void battery_svc(float value, int cells) {
battery_status = battery_level_svc();
ESP_LOGI(TAG, "Called for battery service with volt:%f cells:%d status:%d", value, cells, battery_status);
if(battery_handler_chain) battery_handler_chain(value, cells);
}
/****************************************************************************************
* Initialize the led vu strip if configured.
*
*/
void led_vu_init() {
sys_dev_led_strip* config;
if(!SYS_DEV_LEDSTRIP(config)) {
ESP_LOGI(TAG, "No LED Strip configuration");
return;
}
if(config->gpio < 0) {
ESP_LOGI(TAG, "LED Strip has no GPIO configured");
return;
}
ESP_LOGI(TAG, "Initializing led_vu");
// Initialize led VU strip
strip.length = config->length;
strip.gpio = config->gpio;
// check for valid configuration
if(config->strip_type == sys_dev_strip_types_LS_UNKNOWN || config->gpio < 0) {
ESP_LOGI(TAG, "led_vu configuration invalid");
return;
}
battery_handler_chain = battery_handler_svc;
battery_handler_svc = battery_svc;
battery_status = battery_level_svc();
if(strip.length > LED_VU_MAX_LENGTH) strip.length = LED_VU_MAX_LENGTH;
// initialize vu meter settings
if(strip.length < 10) {
// single bar for small strips
strip.vu_length = strip.length;
strip.vu_start_l = 0;
strip.vu_start_r = strip.vu_start_l;
strip.vu_status = 0;
} else {
strip.vu_length = (strip.length - 1) / 2;
strip.vu_start_l = (strip.length % 2) ? strip.vu_length - 1 : strip.vu_length;
strip.vu_start_r = strip.vu_length + 1;
strip.vu_status = strip.vu_length;
}
ESP_LOGI(TAG, "vu meter using length:%d left:%d right:%d status:%d", strip.vu_length, strip.vu_start_l, strip.vu_start_r, strip.vu_status);
// create driver configuration
led_strip_config.rgb_led_type = config->strip_type == sys_dev_strip_types_LS_WS2812 ? RGB_LED_TYPE_WS2812 : RGB_LED_TYPE_MAX;
led_strip_config.access_semaphore = xSemaphoreCreateBinary();
led_strip_config.led_strip_length = strip.length;
led_strip_config.led_strip_working = heap_caps_malloc(strip.length * sizeof(struct led_color_t), MALLOC_CAP_8BIT);
led_strip_config.led_strip_showing = heap_caps_malloc(strip.length * sizeof(struct led_color_t), MALLOC_CAP_8BIT);
led_strip_config.gpio = strip.gpio;
led_strip_config.rmt_channel = RMT_NEXT_TX_CHANNEL();
// initialize driver
bool led_init_ok = led_strip_init(&led_strip_config);
if(led_init_ok) {
led_display = &led_strip_config;
ESP_LOGI(TAG, "led_vu using gpio:%d length:%d on channel:%d", strip.gpio, strip.length, led_strip_config.rmt_channel);
} else {
ESP_LOGE(TAG, "led_vu init failed");
return;
}
// reserver max memory for remote management systems
rmt_set_mem_block_num(led_strip_config.rmt_channel, 7);
led_vu_clear(led_display);
}
inline bool inRange(double x, double y, double z) { return (x > y && x < z); }
/****************************************************************************************
* Returns the led strip length
*/
uint16_t led_vu_string_length() {
if(!led_display) return 0;
return (uint16_t)strip.length;
}
/****************************************************************************************
* Turns all LEDs off (Black)
*/
void led_vu_clear() {
if(!led_display) return;
led_strip_clear(led_display);
led_strip_show(led_display);
}
/****************************************************************************************
* Sets all LEDs to one color
* r = red (0-255), g = green (0-255), b - blue (0-255)
* note - all colors are adjusted for brightness
*/
void led_vu_color_all(uint8_t r, uint8_t g, uint8_t b) {
if(!led_display) return;
struct led_color_t color_on = {.red = r, .green = g, .blue = b};
for(int i = 0; i < strip.length; i++) { led_strip_set_pixel_color(led_display, i, &color_on); }
led_strip_show(led_display);
}
/****************************************************************************************
* Sets LEDs based on a data packet consiting of rgb data
* offset - starting LED,
* length - number of leds (3x rgb bytes)
* data - array of rgb values in multiples of 3 bytes
*/
void led_vu_data(uint8_t* data, uint16_t offset, uint16_t length) {
if(!led_display) return;
uint8_t* p = (uint8_t*)data;
for(int i = 0; i < length; i++) {
led_strip_set_pixel_rgb(led_display, i + offset, *p, *(p + 1), *(p + 2));
p += 3;
}
led_strip_show(led_display);
}
/****************************************************************************************
* Progress bar display
* data - array of gain values(0-100)
* offset - starting position
* length - size of array
*/
void led_vu_spectrum(uint8_t* data, int bright, int length, int style) {
if(!led_display) return;
uint8_t gain, r, g, b;
int width = strip.length / length;
int pos = 0;
uint8_t* p = (uint8_t*)data;
for(int i = 0; i < length; i++) {
gain = *p;
r = gain * gain / bright;
if(!style) {
g = 0;
b = gain;
} else {
g = r;
r = 0;
b = gain * (bright - gain) / bright;
}
for(int j = 0; j < width; j++) {
led_strip_set_pixel_rgb(led_display, pos, r, g, b);
pos++;
}
p++;
}
led_strip_show(led_display);
}
/****************************************************************************************
* Progress bar display
* pct - percentage complete (0-100)
*/
void led_vu_progress_bar(int pct, int bright) {
if(!led_display) return;
// define colors
struct led_color_t color_on = {.red = bright, .green = 0, .blue = 0};
struct led_color_t color_off = {.red = 0, .green = bright, .blue = 0};
// calcuate led position
int led_lit = strip.length * pct / 100;
// set colors
for(int i = 0; i < strip.length; i++) { led_strip_set_pixel_color(led_display, i, (i < led_lit) ? &color_off : &color_on); }
led_strip_show(led_display);
}
/****************************************************************************************
* Spin dial display
* gain - brightness (0-100), rate - color change speed (0-100)
* comet - alternate display mode
*/
void led_vu_spin_dial(int gain, int rate, int speed, bool comet) {
if(!led_display) return;
static int led_pos = 0;
static uint8_t r = 0;
static uint8_t g = 0;
static uint8_t b = 0;
// calculate next color
uint8_t step = rate / 2; // controls color change speed
if(r == 0 && g == 0 && b == 0) {
r = LED_VU_MAX;
g = step;
} else if(b == 0) {
g = (g > LED_VU_MAX - step) ? LED_VU_MAX : g + step;
r = (r < step) ? 0 : r - step;
if(r == 0) b = step;
} else if(r == 0) {
b = (b > LED_VU_MAX - step) ? LED_VU_MAX : b + step;
g = (g < step) ? 0 : g - step;
if(g == 0) r = step;
} else {
r = (r > LED_VU_MAX - step) ? LED_VU_MAX : r + step;
b = (b < step) ? 0 : b - step;
if(r == 0) b = step;
}
uint8_t rp = r * gain / LED_VU_MAX;
uint8_t gp = g * gain / LED_VU_MAX;
uint8_t bp = b * gain / LED_VU_MAX;
// set led color
speed++;
if(comet) {
led_strip_clear(led_display);
led_strip_set_pixel_rgb(led_display, led_addr(led_pos - 1), rp / 2, gp / 2, bp / 2);
led_strip_set_pixel_rgb(led_display, led_addr(led_pos - 2), rp / 4, gp / 4, bp / 4);
led_strip_set_pixel_rgb(led_display, led_addr(led_pos - 3), rp / 8, gp / 8, bp / 8);
//led_strip_set_pixel_rgb(led_display, led_addr(led_pos-4), 0, 0, 0);
}
for(int i = 0; i < speed; i++) {
led_strip_set_pixel_rgb(led_display, led_pos, rp, gp, bp);
led_pos = led_addr(++led_pos);
}
led_strip_show(led_display);
}
/****************************************************************************************
* VU meter display
* vu_l - left response (0-100), vu_r - right response (0-100)
* comet - alternate display mode
*/
void led_vu_display(int vu_l, int vu_r, int bright, bool comet) {
static int peak_l = 0;
static int peak_r = 0;
static int decay_l = 0;
static int decay_r = 0;
if(!led_display) return;
// single bar
if(strip.vu_start_l == strip.vu_start_r) {
vu_r = (vu_l + vu_r) / 2;
vu_l = 0;
}
// scale vu samples to length
vu_l = vu_l * strip.vu_length / bright;
vu_r = vu_r * strip.vu_length / bright;
// calculate hold peaks
if(peak_l > vu_l) {
if(decay_l-- < 0) {
decay_l = LED_VU_PEAK_HOLD;
peak_l--;
}
} else {
peak_l = vu_l;
decay_l = LED_VU_PEAK_HOLD;
}
if(peak_r > vu_r) {
if(decay_r-- < 0) {
decay_r = LED_VU_PEAK_HOLD;
peak_r--;
}
} else {
peak_r = vu_r;
decay_r = LED_VU_PEAK_HOLD;
}
// turn off all leds
led_strip_clear(led_display);
// set the led bar values
uint8_t step = bright / (strip.vu_length - 1);
if(step < 1) step = 1; // dor low brightness or larger strips
uint8_t g = bright * 2 / 3; // more red at top
uint8_t r = 0;
int shift = 0;
for(int i = 0; i < strip.vu_length; i++) {
// set left
if(i == peak_l) {
led_strip_set_pixel_rgb(led_display, strip.vu_start_l - i, r, g, bright);
} else if(i <= vu_l) {
shift = vu_l - i;
if(comet)
led_strip_set_pixel_rgb(led_display, strip.vu_start_l - i, r >> shift, g >> shift, 0);
else
led_strip_set_pixel_rgb(led_display, strip.vu_start_l - i, r, g, 0);
}
// set right
if(i == peak_r) {
led_strip_set_pixel_rgb(led_display, strip.vu_start_r + i, r, g, bright);
} else if(i <= vu_r) {
shift = vu_r - i;
if(comet)
led_strip_set_pixel_rgb(led_display, strip.vu_start_r + i, r >> shift, g >> shift, 0);
else
led_strip_set_pixel_rgb(led_display, strip.vu_start_r + i, r, g, 0);
}
// adjust colors (with limit checks)
r = (r > bright - step) ? bright : r + step;
g = (g < step) ? 0 : g - step;
}
// show battery status
if(battery_status > LED_VU_STATUS_GREEN)
led_strip_set_pixel_rgb(led_display, strip.vu_status, 0, bright, 0);
else if(battery_status > LED_VU_STATUS_RED)
led_strip_set_pixel_rgb(led_display, strip.vu_status, bright / 2, bright / 2, 0);
else if(battery_status > 0)
led_strip_set_pixel_rgb(led_display, strip.vu_status, bright, 0, 0);
led_strip_show(led_display);
}
Reference in New Issue View Git Blame Copy Permalink