457 lines
14 KiB
C
457 lines
14 KiB
C
#pragma once
|
|
#include <string.h>
|
|
|
|
#include "driver/rmt_tx.h"
|
|
#include "esp_log.h"
|
|
#include "esp_system.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "led_strip_encoder/led_strip_encoder.h"
|
|
#include "nvs.h"
|
|
#include "nvs_flash.h"
|
|
#include "sdkconfig.h"
|
|
|
|
static const char *LIGHT_TAG = "DisplayAmbientLight_Light";
|
|
|
|
#define RMT_TX_GPIO 1
|
|
#define STRIP_LED_NUMBER CONFIG_NUMBER_OF_LEDS
|
|
#define EXAMPLE_CHASE_SPEED_MS (10)
|
|
#define RMT_LED_STRIP_RESOLUTION_HZ 10000000
|
|
|
|
typedef enum light_mode_e {
|
|
light_mode_init = 0,
|
|
light_mode_connection_wifi = 1,
|
|
light_mode_idle = 2,
|
|
light_mode_mqtt_connected = 3,
|
|
light_mode_desktop_online = 4,
|
|
light_mode_desktop_sending_colors = 5,
|
|
light_mode_off = 6,
|
|
} light_mode_t;
|
|
|
|
rmt_channel_handle_t led_chan = NULL;
|
|
static uint8_t led_strip_pixels[STRIP_LED_NUMBER * 3];
|
|
rmt_encoder_handle_t led_encoder = NULL;
|
|
rmt_transmit_config_t tx_config = {
|
|
.loop_count = 0, // no transfer loop
|
|
};
|
|
|
|
light_mode_t light_mode;
|
|
float display_ambient_light_brightness = 1;
|
|
uint8_t display_ambient_lighting_level = 255;
|
|
|
|
float led_strip_red_calibration = 1.0;
|
|
float led_strip_green_calibration = 1.0;
|
|
float led_strip_blue_calibration = 1.0;
|
|
|
|
void led_strip_fade_in_light_level(void *pvParameter) {
|
|
float target = (float)display_ambient_lighting_level / 255.0;
|
|
float step_length = (target - display_ambient_light_brightness) / 40.0;
|
|
for (int t = 0; t < 40; t++) {
|
|
display_ambient_light_brightness += step_length;
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
}
|
|
display_ambient_light_brightness = target;
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
void led_strip_set_brightness(uint8_t level) {
|
|
if (display_ambient_lighting_level == level) {
|
|
return;
|
|
}
|
|
display_ambient_lighting_level = level;
|
|
|
|
xTaskCreate(led_strip_fade_in_light_level, "LED_STRIP_FADE_IN_LIGHT_LEVEL",
|
|
4096, NULL, 1, NULL);
|
|
|
|
nvs_handle_t nvs_handle;
|
|
esp_err_t err = nvs_open("storage", NVS_READWRITE, &nvs_handle);
|
|
err = nvs_set_u8(nvs_handle, "brightness", level);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) saving light level!\n",
|
|
esp_err_to_name(err));
|
|
nvs_close(nvs_handle);
|
|
return;
|
|
}
|
|
err = nvs_commit(nvs_handle);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) saving light level!\n",
|
|
esp_err_to_name(err));
|
|
}
|
|
nvs_close(nvs_handle);
|
|
}
|
|
|
|
void led_strip_set_color_calibration(float red, float green, float blue) {
|
|
led_strip_red_calibration = red;
|
|
led_strip_green_calibration = green;
|
|
led_strip_blue_calibration = blue;
|
|
|
|
nvs_handle_t local_nvs_handle;
|
|
|
|
esp_err_t err = nvs_open("storage", NVS_READWRITE, &local_nvs_handle);
|
|
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) opening NVS handle!\n",
|
|
esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
err = nvs_set_u8(local_nvs_handle, "calibration_r", (uint32_t)(red * 255));
|
|
if (err != ESP_OK) {
|
|
nvs_close(local_nvs_handle);
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) write calibration_r failed!",
|
|
esp_err_to_name(err));
|
|
return;
|
|
}
|
|
err = nvs_set_u8(local_nvs_handle, "calibration_g", (uint8_t)(green * 255));
|
|
if (err != ESP_OK) {
|
|
nvs_close(local_nvs_handle);
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) calibration_g failed!",
|
|
esp_err_to_name(err));
|
|
return;
|
|
}
|
|
err = nvs_set_u8(local_nvs_handle, "calibration_b", (uint8_t)(blue * 255));
|
|
if (err != ESP_OK) {
|
|
nvs_close(local_nvs_handle);
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) calibration_b failed!",
|
|
esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
err = nvs_commit(local_nvs_handle);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) save led_strip_red_calibration failed!",
|
|
esp_err_to_name(err));
|
|
}
|
|
|
|
nvs_close(local_nvs_handle);
|
|
}
|
|
|
|
/**
|
|
* @brief Simple helper function, converting HSV color space to RGB color
|
|
* space
|
|
*
|
|
* Wiki: https://en.wikipedia.org/wiki/HSL_and_HSV
|
|
*
|
|
*/
|
|
void led_strip_hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r,
|
|
uint32_t *g, uint32_t *b) {
|
|
h %= 360; // h -> [0,360]
|
|
uint32_t rgb_max = v * 2.55f;
|
|
uint32_t rgb_min = rgb_max * (100 - s) / 100.0f;
|
|
|
|
uint32_t i = h / 60;
|
|
uint32_t diff = h % 60;
|
|
|
|
// RGB adjustment amount by hue
|
|
uint32_t rgb_adj = (rgb_max - rgb_min) * diff / 60;
|
|
|
|
switch (i) {
|
|
case 0:
|
|
*r = rgb_max;
|
|
*g = rgb_min + rgb_adj;
|
|
*b = rgb_min;
|
|
break;
|
|
case 1:
|
|
*r = rgb_max - rgb_adj;
|
|
*g = rgb_max;
|
|
*b = rgb_min;
|
|
break;
|
|
case 2:
|
|
*r = rgb_min;
|
|
*g = rgb_max;
|
|
*b = rgb_min + rgb_adj;
|
|
break;
|
|
case 3:
|
|
*r = rgb_min;
|
|
*g = rgb_max - rgb_adj;
|
|
*b = rgb_max;
|
|
break;
|
|
case 4:
|
|
*r = rgb_min + rgb_adj;
|
|
*g = rgb_min;
|
|
*b = rgb_max;
|
|
break;
|
|
default:
|
|
*r = rgb_max;
|
|
*g = rgb_min;
|
|
*b = rgb_max - rgb_adj;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// void update_desktop_connection_state() {
|
|
// static uint8_t tick = 0;
|
|
|
|
// bool beat = tick / 10 % 2 ? 1 : 0;
|
|
|
|
// switch (light_mode) {
|
|
// case light_mode_desktop_online:
|
|
// if (beat) {
|
|
// led_strip_pixels[0] = 0;
|
|
// led_strip_pixels[1] = 0;
|
|
// led_strip_pixels[2] = 0;
|
|
// }
|
|
// led_strip_pixels[3] = 10
|
|
// break;
|
|
// case light_mode_mqtt_connected:
|
|
// if (beat) {
|
|
// ESP_ERROR_CHECK(
|
|
// light_led_strip->set_pixel(light_led_strip, 0, 10, 10, 10));
|
|
// ESP_ERROR_CHECK(
|
|
// light_led_strip->set_pixel(light_led_strip, 1, 10, 10, 10));
|
|
// }
|
|
// ESP_ERROR_CHECK(
|
|
// light_led_strip->set_pixel(light_led_strip, 2, 22, 22, 22));
|
|
// break;
|
|
// case light_mode_idle:
|
|
// if (beat) {
|
|
// ESP_ERROR_CHECK(
|
|
// light_led_strip->set_pixel(light_led_strip, 0, 77, 77, 77));
|
|
// ESP_ERROR_CHECK(
|
|
// light_led_strip->set_pixel(light_led_strip, 1, 77, 77, 77));
|
|
// ESP_ERROR_CHECK(
|
|
// light_led_strip->set_pixel(light_led_strip, 2, 77, 77, 77));
|
|
// }
|
|
// break;
|
|
// default:
|
|
// break;
|
|
// }
|
|
|
|
// tick++;
|
|
// }
|
|
|
|
void light_for_init() {
|
|
ESP_LOGI(LIGHT_TAG, "light_for_init");
|
|
|
|
memset(led_strip_pixels, 0, sizeof(led_strip_pixels));
|
|
ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
|
|
sizeof(led_strip_pixels), &tx_config));
|
|
|
|
nvs_handle local_nvs_handle;
|
|
esp_err_t err = nvs_open("storage", NVS_READWRITE, &local_nvs_handle);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) opening NVS handle!", esp_err_to_name(err));
|
|
}
|
|
|
|
uint8_t r = 255, g = 255, b = 255;
|
|
uint8_t brightness = 200;
|
|
err = nvs_get_u8(local_nvs_handle, "calibration_r", &r);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) reading calibration_r!",
|
|
esp_err_to_name(err));
|
|
}
|
|
err = nvs_get_u8(local_nvs_handle, "calibration_g", &g);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) reading calibration_g!",
|
|
esp_err_to_name(err));
|
|
}
|
|
err = nvs_get_u8(local_nvs_handle, "calibration_b", &b);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) reading calibration_b!",
|
|
esp_err_to_name(err));
|
|
}
|
|
err = nvs_get_u8(local_nvs_handle, "brightness", &brightness);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGW(LIGHT_TAG, "Error (%s) reading brightness!", esp_err_to_name(err));
|
|
}
|
|
|
|
nvs_close(local_nvs_handle);
|
|
|
|
// set brightness
|
|
led_strip_set_brightness(brightness);
|
|
|
|
// play init light
|
|
float r_f = (float)r / 255.0;
|
|
float g_f = (float)g / 255.0;
|
|
float b_f = (float)b / 255.0;
|
|
|
|
uint8_t init_r, init_g, init_b;
|
|
|
|
do {
|
|
for (uint8_t i = 0; i < 50; i++) {
|
|
init_r = (uint8_t)(r_f * (float)i);
|
|
init_g = (uint8_t)(g_f * (float)i);
|
|
init_b = (uint8_t)(b_f * (float)i);
|
|
|
|
for (int j = 0; j < STRIP_LED_NUMBER; j++) {
|
|
led_strip_pixels[j * 3 + 0] = init_g;
|
|
led_strip_pixels[j * 3 + 1] = init_r;
|
|
led_strip_pixels[j * 3 + 2] = init_b;
|
|
}
|
|
|
|
ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
|
|
sizeof(led_strip_pixels), &tx_config));
|
|
vTaskDelay(pdMS_TO_TICKS(20));
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
} while (light_mode == light_mode_init);
|
|
|
|
led_strip_set_color_calibration((float)r / 255.0, (float)g / 255.0,
|
|
(float)b / 255.0);
|
|
}
|
|
|
|
void light_for_connecting_wifi() {
|
|
ESP_LOGI(LIGHT_TAG, "light_for_connecting_wifi");
|
|
|
|
int8_t tick_tock = 0;
|
|
|
|
do {
|
|
if (tick_tock) {
|
|
led_strip_pixels[0] = 150;
|
|
led_strip_pixels[1] = 150;
|
|
led_strip_pixels[2] = 0;
|
|
led_strip_pixels[3] = 200;
|
|
led_strip_pixels[4] = 0;
|
|
led_strip_pixels[5] = 0;
|
|
} else {
|
|
led_strip_pixels[0] = 200;
|
|
led_strip_pixels[1] = 0;
|
|
led_strip_pixels[2] = 0;
|
|
led_strip_pixels[3] = 150;
|
|
led_strip_pixels[4] = 150;
|
|
led_strip_pixels[5] = 0;
|
|
}
|
|
tick_tock = !tick_tock;
|
|
ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
|
|
sizeof(led_strip_pixels), &tx_config));
|
|
vTaskDelay(pdMS_TO_TICKS(200));
|
|
} while (light_mode == light_mode_connection_wifi);
|
|
}
|
|
|
|
void light_for_idle() {
|
|
ESP_LOGI(LIGHT_TAG, "light_for_idle");
|
|
|
|
memset(led_strip_pixels, 0, sizeof(led_strip_pixels));
|
|
ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
|
|
sizeof(led_strip_pixels), &tx_config));
|
|
|
|
uint32_t red = 0, green = 0, blue = 0;
|
|
uint16_t step_length = 360 / STRIP_LED_NUMBER;
|
|
|
|
for (uint16_t offset = 0; light_mode == light_mode_idle ||
|
|
light_mode == light_mode_mqtt_connected ||
|
|
light_mode == light_mode_desktop_online;
|
|
offset = (offset + 1) % 360) {
|
|
for (uint16_t j = 0, hue = offset; j < STRIP_LED_NUMBER;
|
|
j++, hue += step_length) {
|
|
// Build RGB values
|
|
led_strip_hsv2rgb(hue, 50, 30, &red, &green, &blue);
|
|
|
|
led_strip_pixels[j * 3 + 0] = green * display_ambient_light_brightness *
|
|
led_strip_green_calibration;
|
|
led_strip_pixels[j * 3 + 1] =
|
|
red * display_ambient_light_brightness * led_strip_red_calibration;
|
|
led_strip_pixels[j * 3 + 2] =
|
|
blue * display_ambient_light_brightness * led_strip_blue_calibration;
|
|
}
|
|
// update_desktop_connection_state();
|
|
ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
|
|
sizeof(led_strip_pixels), &tx_config));
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
}
|
|
}
|
|
|
|
void light_strip_running_task(void *pv_parameters) {
|
|
while (true) {
|
|
if (!led_chan) {
|
|
ESP_LOGE(LIGHT_TAG, "install WS2812 driver failed 2");
|
|
}
|
|
switch (light_mode) {
|
|
case light_mode_init:
|
|
light_for_init();
|
|
break;
|
|
case light_mode_connection_wifi:
|
|
light_for_connecting_wifi();
|
|
break;
|
|
case light_mode_idle:
|
|
case light_mode_mqtt_connected:
|
|
case light_mode_desktop_online:
|
|
light_for_idle();
|
|
break;
|
|
default:
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
break;
|
|
}
|
|
}
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
void light_init_strip() {
|
|
rmt_tx_channel_config_t tx_chan_config = {
|
|
.clk_src = RMT_CLK_SRC_DEFAULT, // select source clock
|
|
.gpio_num = RMT_TX_GPIO,
|
|
.mem_block_symbols =
|
|
64, // increase the block size can make the LED less flickering
|
|
.resolution_hz = RMT_LED_STRIP_RESOLUTION_HZ,
|
|
.trans_queue_depth = 4, // set the number of transactions that can be
|
|
// pending in the background
|
|
};
|
|
ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &led_chan));
|
|
|
|
ESP_LOGI(LIGHT_TAG, "Install led strip encoder");
|
|
|
|
led_strip_encoder_config_t encoder_config = {
|
|
.resolution = RMT_LED_STRIP_RESOLUTION_HZ,
|
|
};
|
|
ESP_ERROR_CHECK(rmt_new_led_strip_encoder(&encoder_config, &led_encoder));
|
|
|
|
ESP_LOGI(LIGHT_TAG, "Enable RMT TX channel");
|
|
ESP_ERROR_CHECK(rmt_enable(led_chan));
|
|
|
|
ESP_LOGI(LIGHT_TAG, "Start LED rainbow chase");
|
|
|
|
light_mode = light_mode_init;
|
|
|
|
xTaskCreate(light_strip_running_task, "LIGHT_STRIP_RUNNING_TASK", 4096, NULL,
|
|
1, NULL);
|
|
}
|
|
|
|
void light_play_colors(uint16_t len, uint8_t *buffer) {
|
|
light_mode = light_mode_desktop_sending_colors;
|
|
|
|
uint16_t black_count = 0; // count of black pixels. r/g/b <= 10
|
|
|
|
for (uint16_t led_index = 0, buffer_cursor = 0;
|
|
led_index < STRIP_LED_NUMBER && buffer_cursor < len;
|
|
led_index++, buffer_cursor += 3) {
|
|
uint8_t r = (uint8_t)((float)buffer[buffer_cursor] *
|
|
display_ambient_light_brightness *
|
|
led_strip_red_calibration),
|
|
g = (uint8_t)((float)buffer[buffer_cursor + 1] *
|
|
display_ambient_light_brightness *
|
|
led_strip_green_calibration),
|
|
b = (uint8_t)((float)buffer[buffer_cursor + 2] *
|
|
display_ambient_light_brightness *
|
|
led_strip_blue_calibration);
|
|
if (r <= 7 && g <= 7 && b <= 7) {
|
|
black_count++;
|
|
}
|
|
led_strip_pixels[led_index * 3 + 0] = g;
|
|
led_strip_pixels[led_index * 3 + 1] = r;
|
|
led_strip_pixels[led_index * 3 + 2] = b;
|
|
}
|
|
|
|
if (black_count > STRIP_LED_NUMBER / 5 * 4) {
|
|
uint8_t r = (uint8_t)((float)50 * display_ambient_light_brightness *
|
|
led_strip_red_calibration),
|
|
g = (uint8_t)((float)40 * display_ambient_light_brightness *
|
|
led_strip_green_calibration),
|
|
b = (uint8_t)((float)20 * display_ambient_light_brightness *
|
|
led_strip_blue_calibration);
|
|
for (uint16_t led_index = 0; led_index < STRIP_LED_NUMBER; led_index++) {
|
|
led_strip_pixels[led_index * 3 + 0] = g;
|
|
led_strip_pixels[led_index * 3 + 1] = r;
|
|
led_strip_pixels[led_index * 3 + 2] = b;
|
|
}
|
|
}
|
|
|
|
ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
|
|
sizeof(led_strip_pixels), &tx_config));
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
}
|
|
|
|
void light_play(light_mode_t mode) {
|
|
ESP_LOGI(LIGHT_TAG, "light_play: %d", mode);
|
|
light_mode = mode;
|
|
}
|