2023-11-07 21:26:15 +01:00
|
|
|
#include "led_handler.hpp"
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
// Singleton instance
|
|
|
|
LedHandler& LedHandler::getInstance() {
|
|
|
|
static LedHandler instance;
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
|
|
|
|
LedHandler::LedHandler()
|
|
|
|
: pixels(NEOPIXEL_COUNT, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800)
|
|
|
|
, ledTaskHandle(nullptr)
|
|
|
|
, ledTaskQueue(nullptr)
|
|
|
|
, ledTaskParams(0)
|
|
|
|
, dndEnabled(false)
|
|
|
|
, dndTimeBasedEnabled(false)
|
|
|
|
, dndTimeRange{23, 0, 7, 0} // Default: 23:00 to 07:00
|
2024-06-08 01:00:52 +02:00
|
|
|
#ifdef HAS_FRONTLIGHT
|
2025-01-05 21:19:28 +01:00
|
|
|
, frontlightOn(false)
|
|
|
|
, flInTransition(false)
|
|
|
|
#endif
|
2024-06-08 01:00:52 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setup() {
|
|
|
|
loadDNDSettings();
|
|
|
|
pixels.begin();
|
|
|
|
pixels.setBrightness(preferences.getUInt("ledBrightness", DEFAULT_LED_BRIGHTNESS));
|
|
|
|
pixels.clear();
|
|
|
|
pixels.show();
|
|
|
|
setupTask();
|
|
|
|
|
|
|
|
if (preferences.getBool("ledTestOnPower", DEFAULT_LED_TEST_ON_POWER)) {
|
|
|
|
while (!ledTaskQueue) {
|
|
|
|
delay(1);
|
|
|
|
}
|
|
|
|
queueEffect(LED_POWER_TEST);
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setupTask() {
|
|
|
|
ledTaskQueue = xQueueCreate(5, sizeof(uint));
|
|
|
|
xTaskCreate(ledTask, "LedTask", 2048, this, 10, &ledTaskHandle);
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::ledTask(void* pvParameters) {
|
|
|
|
auto* handler = static_cast<LedHandler*>(pvParameters);
|
|
|
|
while (true) {
|
|
|
|
if (handler->ledTaskQueue != nullptr) {
|
|
|
|
if (xQueueReceive(handler->ledTaskQueue, &handler->ledTaskParams, portMAX_DELAY) == pdPASS) {
|
|
|
|
if (preferences.getBool("disableLeds", DEFAULT_DISABLE_LEDS)) {
|
|
|
|
continue;
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
std::array<uint32_t, NEOPIXEL_COUNT> oldLights;
|
|
|
|
for (int i = 0; i < NEOPIXEL_COUNT; i++) {
|
|
|
|
oldLights[i] = handler->pixels.getPixelColor(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
|
|
|
uint flDelayTime = preferences.getUInt("flEffectDelay");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
switch (handler->ledTaskParams) {
|
|
|
|
case LED_POWER_TEST:
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
|
|
|
handler->frontlightFadeInAll(preferences.getUInt("flEffectDelay"), true);
|
|
|
|
#endif
|
|
|
|
handler->rainbow(20);
|
|
|
|
handler->pixels.clear();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_WIFI_CONNECT_ERROR:
|
|
|
|
handler->blinkDelayTwoColor(100, 3, handler->pixels.Color(8, 161, 236),
|
|
|
|
handler->pixels.Color(255, 0, 0));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_CONFIGURING:
|
|
|
|
for (int i = NEOPIXEL_COUNT; i--; i > 0) {
|
|
|
|
for (int j = NEOPIXEL_COUNT; j--; j > 0) {
|
|
|
|
uint32_t c = handler->pixels.Color(0, 0, 0);
|
|
|
|
if (i == j)
|
|
|
|
c = handler->pixels.Color(0, 0, 255);
|
|
|
|
handler->pixels.setPixelColor(j, c);
|
|
|
|
}
|
|
|
|
handler->pixels.show();
|
|
|
|
delay(100);
|
|
|
|
}
|
|
|
|
handler->pixels.clear();
|
|
|
|
handler->pixels.show();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_FLASH_ERROR:
|
|
|
|
handler->blinkDelayColor(250, 3, 255, 0, 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_HEARTBEAT:
|
|
|
|
handler->blinkDelayColor(150, 2, 0, 0, 255);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_DATA_BLOCK_ERROR:
|
|
|
|
handler->blinkDelayColor(150, 2, 128, 0, 128);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_DATA_PRICE_ERROR:
|
|
|
|
handler->blinkDelayColor(150, 2, 177, 90, 31);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_FLASH_IDENTIFY:
|
|
|
|
handler->blinkDelayTwoColor(100, 2, handler->pixels.Color(255, 0, 0),
|
|
|
|
handler->pixels.Color(0, 255, 255));
|
|
|
|
handler->blinkDelayTwoColor(100, 2, handler->pixels.Color(0, 255, 0),
|
|
|
|
handler->pixels.Color(0, 0, 255));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_WIFI_CONNECT_SUCCESS:
|
|
|
|
case LED_FLASH_SUCCESS:
|
|
|
|
handler->blinkDelayColor(150, 3, 0, 255, 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_PROGRESS_100:
|
|
|
|
handler->pixels.setPixelColor(0, handler->pixels.Color(0, 255, 0));
|
|
|
|
[[fallthrough]];
|
|
|
|
case LED_PROGRESS_75:
|
|
|
|
handler->pixels.setPixelColor(1, handler->pixels.Color(0, 255, 0));
|
|
|
|
[[fallthrough]];
|
|
|
|
case LED_PROGRESS_50:
|
|
|
|
handler->pixels.setPixelColor(2, handler->pixels.Color(0, 255, 0));
|
|
|
|
[[fallthrough]];
|
|
|
|
case LED_PROGRESS_25:
|
|
|
|
handler->pixels.setPixelColor(3, handler->pixels.Color(0, 255, 0));
|
|
|
|
handler->pixels.show();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_NOSTR_ZAP:
|
|
|
|
{
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
|
|
|
bool frontlightWasOn = false;
|
|
|
|
if (preferences.getBool("flFlashOnZap", DEFAULT_FL_FLASH_ON_ZAP)) {
|
|
|
|
if (handler->frontlightOn) {
|
|
|
|
frontlightWasOn = true;
|
|
|
|
handler->frontlightFadeOutAll(flDelayTime, true);
|
|
|
|
} else {
|
|
|
|
handler->frontlightFadeInAll(flDelayTime, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
for (int flash = 0; flash < random(7, 10); flash++) {
|
|
|
|
handler->lightningStrike();
|
|
|
|
delay(random(50, 150));
|
|
|
|
}
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
|
|
|
if (preferences.getBool("flFlashOnZap", DEFAULT_FL_FLASH_ON_ZAP)) {
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
|
|
if (frontlightWasOn) {
|
|
|
|
handler->frontlightFadeInAll(flDelayTime, true);
|
|
|
|
} else {
|
|
|
|
handler->frontlightFadeOutAll(flDelayTime, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
case LED_FLASH_UPDATE:
|
|
|
|
handler->blinkDelayTwoColor(250, 3, handler->pixels.Color(0, 230, 0),
|
|
|
|
handler->pixels.Color(230, 230, 0));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_FLASH_BLOCK_NOTIFY:
|
|
|
|
{
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
|
|
|
bool frontlightWasOn = false;
|
|
|
|
if (preferences.getBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE)) {
|
|
|
|
if (handler->frontlightOn) {
|
|
|
|
frontlightWasOn = true;
|
|
|
|
handler->frontlightFadeOutAll(flDelayTime, true);
|
|
|
|
} else {
|
|
|
|
handler->frontlightFadeInAll(flDelayTime, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
handler->blinkDelayTwoColor(250, 3, handler->pixels.Color(224, 67, 0),
|
|
|
|
handler->pixels.Color(8, 2, 0));
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
|
|
|
if (preferences.getBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE)) {
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
|
|
if (frontlightWasOn) {
|
|
|
|
handler->frontlightFadeInAll(flDelayTime, true);
|
|
|
|
} else {
|
|
|
|
handler->frontlightFadeOutAll(flDelayTime, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case LED_EFFECT_WIFI_WAIT_FOR_CONFIG:
|
|
|
|
handler->blinkDelayTwoColor(100, 1, handler->pixels.Color(8, 161, 236),
|
|
|
|
handler->pixels.Color(156, 225, 240));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_WIFI_ERASE_SETTINGS:
|
|
|
|
handler->blinkDelay(100, 3);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_WIFI_CONNECTING:
|
|
|
|
for (int i = NEOPIXEL_COUNT; i >= 0; i--) {
|
|
|
|
for (int j = NEOPIXEL_COUNT; j >= 0; j--) {
|
|
|
|
if (j == i) {
|
|
|
|
handler->pixels.setPixelColor(i, handler->pixels.Color(16, 197, 236));
|
|
|
|
} else {
|
|
|
|
handler->pixels.setPixelColor(j, handler->pixels.Color(0, 0, 0));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
handler->pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_PAUSE_TIMER:
|
|
|
|
for (int i = NEOPIXEL_COUNT; i >= 0; i--) {
|
|
|
|
for (int j = NEOPIXEL_COUNT; j >= 0; j--) {
|
|
|
|
uint32_t c = handler->pixels.Color(0, 0, 0);
|
|
|
|
if (i == j)
|
|
|
|
c = handler->pixels.Color(0, 255, 0);
|
|
|
|
handler->pixels.setPixelColor(j, c);
|
|
|
|
}
|
|
|
|
handler->pixels.show();
|
|
|
|
delay(100);
|
|
|
|
}
|
|
|
|
handler->pixels.setPixelColor(0, handler->pixels.Color(255, 0, 0));
|
|
|
|
handler->pixels.show();
|
|
|
|
delay(900);
|
|
|
|
handler->pixels.clear();
|
|
|
|
handler->pixels.show();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LED_EFFECT_START_TIMER:
|
|
|
|
handler->pixels.clear();
|
|
|
|
handler->pixels.setPixelColor((NEOPIXEL_COUNT - 1), handler->pixels.Color(255, 0, 0));
|
|
|
|
handler->pixels.show();
|
|
|
|
delay(900);
|
|
|
|
for (int i = NEOPIXEL_COUNT; i--; i > 0) {
|
|
|
|
for (int j = NEOPIXEL_COUNT; j--; j > 0) {
|
|
|
|
uint32_t c = handler->pixels.Color(0, 0, 0);
|
|
|
|
if (i == j)
|
|
|
|
c = handler->pixels.Color(0, 255, 0);
|
|
|
|
handler->pixels.setPixelColor(j, c);
|
|
|
|
}
|
|
|
|
handler->pixels.show();
|
|
|
|
delay(100);
|
|
|
|
}
|
|
|
|
handler->pixels.clear();
|
|
|
|
handler->pixels.show();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Restore previous state unless power test
|
|
|
|
for (int i = 0; i < NEOPIXEL_COUNT; i++) {
|
|
|
|
handler->pixels.setPixelColor(i, oldLights[i]);
|
|
|
|
}
|
|
|
|
handler->pixels.show();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
bool LedHandler::queueEffect(uint effect) {
|
|
|
|
if (isDNDActive()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (ledTaskQueue == nullptr) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
xQueueSend(ledTaskQueue, &effect, portMAX_DELAY);
|
|
|
|
return true;
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::clear() {
|
|
|
|
preferences.putBool("ledStatus", false);
|
|
|
|
pixels.clear();
|
|
|
|
pixels.show();
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setLights(int r, int g, int b) {
|
|
|
|
setLights(pixels.Color(r, g, b));
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setLights(uint32_t color) {
|
|
|
|
bool ledStatus = true;
|
|
|
|
for (int i = 0; i < NEOPIXEL_COUNT; i++) {
|
|
|
|
pixels.setPixelColor(i, color);
|
|
|
|
}
|
|
|
|
pixels.show();
|
2024-12-26 22:20:30 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
if (color == pixels.Color(0, 0, 0)) {
|
|
|
|
ledStatus = false;
|
|
|
|
} else {
|
|
|
|
saveLedState();
|
|
|
|
}
|
|
|
|
preferences.putBool("ledStatus", ledStatus);
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::saveLedState() {
|
|
|
|
for (int i = 0; i < pixels.numPixels(); i++) {
|
|
|
|
int pixelColor = pixels.getPixelColor(i);
|
|
|
|
char key[12];
|
|
|
|
snprintf(key, 12, "%s%d", "ledColor_", i);
|
|
|
|
preferences.putUInt(key, pixelColor);
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
xTaskNotifyGive(eventSourceTaskHandle);
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::restoreLedState() {
|
|
|
|
for (int i = 0; i < pixels.numPixels(); i++) {
|
|
|
|
char key[12];
|
|
|
|
snprintf(key, 12, "%s%d", "ledColor_", i);
|
|
|
|
uint pixelColor = preferences.getUInt(key, pixels.Color(0, 0, 0));
|
|
|
|
pixels.setPixelColor(i, pixelColor);
|
|
|
|
}
|
|
|
|
pixels.show();
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::rainbow(int wait) {
|
|
|
|
for (long firstPixelHue = 0; firstPixelHue < 5 * 65536; firstPixelHue += 256) {
|
|
|
|
pixels.rainbow(firstPixelHue);
|
|
|
|
pixels.show();
|
|
|
|
delayMicroseconds(wait);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void LedHandler::theaterChase(uint32_t color, int wait) {
|
|
|
|
for (int a = 0; a < 10; a++) {
|
|
|
|
for (int b = 0; b < 3; b++) {
|
|
|
|
pixels.clear();
|
|
|
|
for (int c = b; c < pixels.numPixels(); c += 3) {
|
|
|
|
pixels.setPixelColor(c, color);
|
|
|
|
}
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(wait));
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::theaterChaseRainbow(int wait) {
|
|
|
|
int firstPixelHue = 0;
|
|
|
|
for (int a = 0; a < 30; a++) {
|
|
|
|
for (int b = 0; b < 3; b++) {
|
|
|
|
pixels.clear();
|
|
|
|
for (int c = b; c < pixels.numPixels(); c += 3) {
|
|
|
|
int hue = firstPixelHue + c * 65536L / pixels.numPixels();
|
|
|
|
uint32_t color = pixels.gamma32(pixels.ColorHSV(hue));
|
|
|
|
pixels.setPixelColor(c, color);
|
|
|
|
}
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(wait));
|
|
|
|
firstPixelHue += 65536 / 90;
|
|
|
|
}
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::lightningStrike() {
|
|
|
|
uint32_t PURPLE = pixels.Color(128, 0, 128);
|
|
|
|
uint32_t YELLOW = pixels.Color(255, 226, 41);
|
2024-06-29 02:19:25 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
for (int i = 0; i < pixels.numPixels(); i++) {
|
|
|
|
pixels.setPixelColor(i, random(2) == 0 ? YELLOW : PURPLE);
|
|
|
|
}
|
|
|
|
pixels.show();
|
|
|
|
delay(random(10, 50));
|
2024-06-29 02:19:25 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::blinkDelay(int d, int times) {
|
|
|
|
for (int j = 0; j < times; j++) {
|
|
|
|
pixels.setPixelColor(0, pixels.Color(255, 0, 0));
|
|
|
|
pixels.setPixelColor(1, pixels.Color(0, 255, 0));
|
|
|
|
pixels.setPixelColor(2, pixels.Color(255, 0, 0));
|
|
|
|
pixels.setPixelColor(3, pixels.Color(0, 255, 0));
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(d));
|
|
|
|
|
|
|
|
pixels.setPixelColor(0, pixels.Color(255, 255, 0));
|
|
|
|
pixels.setPixelColor(1, pixels.Color(0, 255, 255));
|
|
|
|
pixels.setPixelColor(2, pixels.Color(255, 255, 0));
|
|
|
|
pixels.setPixelColor(3, pixels.Color(0, 255, 255));
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(d));
|
|
|
|
}
|
|
|
|
pixels.clear();
|
|
|
|
pixels.show();
|
2024-06-29 02:19:25 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::blinkDelayColor(int d, int times, uint r, uint g, uint b) {
|
|
|
|
for (int j = 0; j < times; j++) {
|
|
|
|
for (int i = 0; i < NEOPIXEL_COUNT; i++) {
|
|
|
|
pixels.setPixelColor(i, pixels.Color(r, g, b));
|
|
|
|
}
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(d));
|
|
|
|
|
|
|
|
pixels.clear();
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(d));
|
|
|
|
}
|
|
|
|
pixels.clear();
|
|
|
|
pixels.show();
|
2024-06-08 01:00:52 +02:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::blinkDelayTwoColor(int d, int times, const uint32_t& c1, const uint32_t& c2) {
|
|
|
|
for (int j = 0; j < times; j++) {
|
|
|
|
for (int i = 0; i < NEOPIXEL_COUNT; i++) {
|
|
|
|
pixels.setPixelColor(i, c1);
|
|
|
|
}
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(d));
|
2024-12-30 02:04:18 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
for (int i = 0; i < NEOPIXEL_COUNT; i++) {
|
|
|
|
pixels.setPixelColor(i, c2);
|
|
|
|
}
|
|
|
|
pixels.show();
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(d));
|
|
|
|
}
|
|
|
|
pixels.clear();
|
|
|
|
pixels.show();
|
|
|
|
}
|
|
|
|
|
|
|
|
// DND Implementation
|
|
|
|
void LedHandler::loadDNDSettings() {
|
2024-12-30 02:04:18 +01:00
|
|
|
dndEnabled = preferences.getBool("dndEnabled", false);
|
|
|
|
dndTimeBasedEnabled = preferences.getBool("dndTimeEnabled", false);
|
|
|
|
|
|
|
|
dndTimeRange.startHour = preferences.getUChar("dndStartHour", 23);
|
|
|
|
dndTimeRange.startMinute = preferences.getUChar("dndStartMin", 0);
|
|
|
|
dndTimeRange.endHour = preferences.getUChar("dndEndHour", 7);
|
|
|
|
dndTimeRange.endMinute = preferences.getUChar("dndEndMin", 0);
|
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setDNDEnabled(bool enabled) {
|
2024-12-30 02:04:18 +01:00
|
|
|
dndEnabled = enabled;
|
|
|
|
preferences.putBool("dndEnabled", enabled);
|
|
|
|
if (enabled && isDNDActive()) {
|
2025-01-05 21:19:28 +01:00
|
|
|
clear();
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
2024-12-30 02:04:18 +01:00
|
|
|
frontlightFadeOutAll();
|
2025-01-05 21:19:28 +01:00
|
|
|
#endif
|
2024-12-30 02:04:18 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setDNDTimeBasedEnabled(bool enabled) {
|
2024-12-30 02:04:18 +01:00
|
|
|
dndTimeBasedEnabled = enabled;
|
|
|
|
preferences.putBool("dndTimeEnabled", enabled);
|
|
|
|
if (enabled && isDNDActive()) {
|
2025-01-05 21:19:28 +01:00
|
|
|
clear();
|
|
|
|
#ifdef HAS_FRONTLIGHT
|
2024-12-30 02:04:18 +01:00
|
|
|
frontlightFadeOutAll();
|
2025-01-05 21:19:28 +01:00
|
|
|
#endif
|
2024-12-30 02:04:18 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::setDNDTimeRange(uint8_t startHour, uint8_t startMinute, uint8_t endHour, uint8_t endMinute) {
|
2024-12-30 02:04:18 +01:00
|
|
|
dndTimeRange.startHour = startHour;
|
|
|
|
dndTimeRange.startMinute = startMinute;
|
|
|
|
dndTimeRange.endHour = endHour;
|
|
|
|
dndTimeRange.endMinute = endMinute;
|
|
|
|
|
|
|
|
preferences.putUChar("dndStartHour", startHour);
|
|
|
|
preferences.putUChar("dndStartMin", startMinute);
|
|
|
|
preferences.putUChar("dndEndHour", endHour);
|
|
|
|
preferences.putUChar("dndEndMin", endMinute);
|
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
bool LedHandler::isTimeInDNDRange(uint8_t hour, uint8_t minute) const {
|
2024-12-30 02:04:18 +01:00
|
|
|
uint16_t currentTime = hour * 60 + minute;
|
|
|
|
uint16_t startTime = dndTimeRange.startHour * 60 + dndTimeRange.startMinute;
|
|
|
|
uint16_t endTime = dndTimeRange.endHour * 60 + dndTimeRange.endMinute;
|
|
|
|
|
|
|
|
if (startTime <= endTime) {
|
|
|
|
return currentTime >= startTime && currentTime < endTime;
|
|
|
|
} else {
|
|
|
|
return currentTime >= startTime || currentTime < endTime;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
bool LedHandler::isDNDActive() const {
|
2024-12-30 02:04:18 +01:00
|
|
|
if (dndEnabled) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dndTimeBasedEnabled) {
|
|
|
|
time_t now;
|
|
|
|
struct tm timeinfo;
|
|
|
|
time(&now);
|
|
|
|
localtime_r(&now, &timeinfo);
|
|
|
|
return isTimeInDNDRange(timeinfo.tm_hour, timeinfo.tm_min);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2024-07-10 01:08:42 +02:00
|
|
|
#ifdef HAS_FRONTLIGHT
|
2025-01-05 21:19:28 +01:00
|
|
|
// Frontlight implementation
|
|
|
|
void LedHandler::frontlightFlash(int flDelayTime) {
|
|
|
|
if (preferences.getBool("flDisable")) {
|
|
|
|
return;
|
|
|
|
}
|
2024-12-31 11:51:34 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
if (frontlightOn) {
|
|
|
|
frontlightFadeOutAll(flDelayTime, true);
|
|
|
|
frontlightFadeInAll(flDelayTime, true);
|
|
|
|
} else {
|
|
|
|
frontlightFadeInAll(flDelayTime, true);
|
|
|
|
frontlightFadeOutAll(flDelayTime, true);
|
|
|
|
}
|
|
|
|
}
|
2024-12-31 11:51:34 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeInAll() {
|
|
|
|
frontlightFadeInAll(preferences.getUInt("flEffectDelay"));
|
|
|
|
}
|
2023-11-30 22:38:01 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeOutAll() {
|
|
|
|
frontlightFadeOutAll(preferences.getUInt("flEffectDelay"));
|
|
|
|
}
|
2023-11-30 22:38:01 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeIn(uint num) {
|
|
|
|
frontlightFadeIn(num, preferences.getUInt("flEffectDelay"));
|
|
|
|
}
|
2023-11-30 22:38:01 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeOut(uint num) {
|
|
|
|
frontlightFadeOut(num, preferences.getUInt("flEffectDelay"));
|
|
|
|
}
|
2023-11-30 22:38:01 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightSetBrightness(uint brightness) {
|
|
|
|
if (isDNDActive() || brightness > 4096) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int ledPin = 0; ledPin <= NUM_SCREENS; ledPin++) {
|
|
|
|
flArray.setPWM(ledPin, 0, brightness);
|
|
|
|
}
|
|
|
|
}
|
2024-06-08 01:00:52 +02:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
std::vector<uint16_t> LedHandler::frontlightGetStatus() {
|
|
|
|
std::vector<uint16_t> statuses;
|
|
|
|
for (int ledPin = 1; ledPin <= NUM_SCREENS; ledPin++) {
|
|
|
|
uint16_t a = 0, b = 0;
|
|
|
|
flArray.getPWM(ledPin, &a, &b);
|
|
|
|
statuses.push_back(round(b - a / 4096));
|
|
|
|
}
|
|
|
|
return statuses;
|
|
|
|
}
|
2023-11-30 22:38:01 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeInAll(int flDelayTime, bool staggered) {
|
|
|
|
if (preferences.getBool("flDisable") || frontlightIsOn() || flInTransition) {
|
|
|
|
return;
|
|
|
|
}
|
2023-11-30 22:38:01 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
flInTransition = true;
|
|
|
|
const int maxBrightness = preferences.getUInt("flMaxBrightness");
|
|
|
|
|
|
|
|
if (staggered) {
|
|
|
|
int step = FL_FADE_STEP;
|
|
|
|
int staggerDelay = flDelayTime / NUM_SCREENS;
|
|
|
|
|
|
|
|
for (int dutyCycle = 0; dutyCycle <= maxBrightness + (NUM_SCREENS - 1) * maxBrightness / NUM_SCREENS; dutyCycle += step) {
|
|
|
|
for (int ledPin = 0; ledPin < NUM_SCREENS; ledPin++) {
|
|
|
|
int ledBrightness = dutyCycle - ledPin * maxBrightness / NUM_SCREENS;
|
|
|
|
if (ledBrightness < 0) {
|
|
|
|
ledBrightness = 0;
|
|
|
|
} else if (ledBrightness > maxBrightness) {
|
|
|
|
ledBrightness = maxBrightness;
|
|
|
|
}
|
|
|
|
flArray.setPWM(ledPin + 1, 0, ledBrightness);
|
2023-11-30 22:38:01 +01:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
vTaskDelay(pdMS_TO_TICKS(staggerDelay));
|
2023-11-08 12:18:59 +01:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
} else {
|
|
|
|
for (int dutyCycle = 0; dutyCycle <= maxBrightness; dutyCycle += FL_FADE_STEP) {
|
|
|
|
for (int ledPin = 0; ledPin <= NUM_SCREENS; ledPin++) {
|
|
|
|
flArray.setPWM(ledPin, 0, dutyCycle);
|
|
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(flDelayTime));
|
2023-11-30 22:38:01 +01:00
|
|
|
}
|
2023-11-07 21:26:15 +01:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
frontlightOn = true;
|
|
|
|
flInTransition = false;
|
2023-11-07 21:26:15 +01:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeOutAll(int flDelayTime, bool staggered) {
|
|
|
|
if (preferences.getBool("flDisable") || !frontlightIsOn() || flInTransition) {
|
|
|
|
return;
|
2023-11-10 13:02:05 +01:00
|
|
|
}
|
2023-11-08 12:18:59 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
flInTransition = true;
|
|
|
|
if (staggered) {
|
|
|
|
int maxBrightness = preferences.getUInt("flMaxBrightness");
|
|
|
|
int step = FL_FADE_STEP;
|
|
|
|
int staggerDelay = flDelayTime / NUM_SCREENS;
|
|
|
|
|
|
|
|
for (int dutyCycle = maxBrightness; dutyCycle >= 0; dutyCycle -= step) {
|
|
|
|
for (int ledPin = 0; ledPin < NUM_SCREENS; ledPin++) {
|
|
|
|
int ledBrightness = dutyCycle - (NUM_SCREENS - 1 - ledPin) * maxBrightness / NUM_SCREENS;
|
|
|
|
if (ledBrightness < 0) {
|
|
|
|
ledBrightness = 0;
|
|
|
|
} else if (ledBrightness > maxBrightness) {
|
|
|
|
ledBrightness = maxBrightness;
|
|
|
|
}
|
|
|
|
flArray.setPWM(ledPin + 1, 0, ledBrightness);
|
|
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(staggerDelay));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (int dutyCycle = preferences.getUInt("flMaxBrightness"); dutyCycle >= 0; dutyCycle -= FL_FADE_STEP) {
|
|
|
|
for (int ledPin = 0; ledPin <= NUM_SCREENS; ledPin++) {
|
|
|
|
flArray.setPWM(ledPin, 0, dutyCycle);
|
|
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(flDelayTime));
|
|
|
|
}
|
|
|
|
}
|
2023-11-08 12:18:59 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
flArray.allOFF();
|
|
|
|
frontlightOn = false;
|
|
|
|
flInTransition = false;
|
2023-11-08 12:18:59 +01:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeIn(uint num, int flDelayTime) {
|
|
|
|
if (isDNDActive() || preferences.getBool("flDisable")) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int dutyCycle = 0; dutyCycle <= preferences.getUInt("flMaxBrightness"); dutyCycle += 5) {
|
|
|
|
flArray.setPWM(num, 0, dutyCycle);
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(flDelayTime));
|
|
|
|
}
|
2023-11-07 21:26:15 +01:00
|
|
|
}
|
2023-11-08 12:18:59 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::frontlightFadeOut(uint num, int flDelayTime) {
|
|
|
|
if (isDNDActive() || preferences.getBool("flDisable") || !frontlightIsOn()) {
|
|
|
|
return;
|
2023-11-30 22:38:01 +01:00
|
|
|
}
|
2023-11-08 12:18:59 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
for (int dutyCycle = preferences.getUInt("flMaxBrightness"); dutyCycle >= 0; dutyCycle -= 5) {
|
|
|
|
flArray.setPWM(num, 0, dutyCycle);
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(flDelayTime));
|
|
|
|
}
|
2023-11-08 12:18:59 +01:00
|
|
|
}
|
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
void LedHandler::initializeFrontlight() {
|
|
|
|
if (!flArray.begin(PCA9685_MODE1_AUTOINCR | PCA9685_MODE1_ALLCALL, PCA9685_MODE2_TOTEMPOLE))
|
2024-06-08 01:00:52 +02:00
|
|
|
{
|
2025-01-05 21:19:28 +01:00
|
|
|
Serial.println(F("FL driver error"));
|
|
|
|
return;
|
2023-11-08 12:18:59 +01:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
flArray.setFrequency(200);
|
|
|
|
Serial.println(F("FL driver active"));
|
2023-11-08 12:18:59 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
if (!preferences.isKey("flMaxBrightness"))
|
2024-06-08 01:00:52 +02:00
|
|
|
{
|
2025-01-05 21:19:28 +01:00
|
|
|
preferences.putUInt("flMaxBrightness", DEFAULT_FL_MAX_BRIGHTNESS);
|
2024-12-30 02:04:18 +01:00
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
if (!preferences.isKey("flEffectDelay"))
|
2024-12-30 02:04:18 +01:00
|
|
|
{
|
2025-01-05 21:19:28 +01:00
|
|
|
preferences.putUInt("flEffectDelay", DEFAULT_FL_EFFECT_DELAY);
|
2024-12-30 02:04:18 +01:00
|
|
|
}
|
2023-11-08 12:18:59 +01:00
|
|
|
|
2025-01-05 21:19:28 +01:00
|
|
|
if (!preferences.isKey("flFlashOnUpd"))
|
2024-09-11 03:23:41 +02:00
|
|
|
{
|
2025-01-05 21:19:28 +01:00
|
|
|
preferences.putBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE);
|
2024-09-11 03:23:41 +02:00
|
|
|
}
|
|
|
|
}
|
2025-01-05 21:19:28 +01:00
|
|
|
#endif
|