mirrors/unleashed-firmware
1
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware.git synced 2025-12-12 12:42:30 +04:00
Code Issues Activity

Merge pull request #881 from Dmitry422/dev

Browse Source 
RGB BACKLIGHT refactoring.
This commit is contained in:
MMX
2025-03-24 03:32:56 +03:00
committed by GitHub
parent b48e00928a f52c9855d6
commit 472f7e76f3
6 changed files with 507 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

234
applications/services/rgb_backlight/rgb_backlight.c
View File

@@ -23,11 +23,26 @@
#include <furi_hal.h> #include <furi_hal.h>
#include <storage/storage.h> #include <storage/storage.h>
#include "rgb_backlight.h" #include "rgb_backlight.h"
#include <math.h>
#define COLOR_COUNT (sizeof(colors) / sizeof(RGBBacklightColor)) #define COLOR_COUNT (sizeof(colors) / sizeof(RGBBacklightColor))
#define TAG "RGB_BACKLIGHT_SRV" #define TAG "RGB_BACKLIGHT_SRV"
typedef struct {
char* name;
uint8_t red;
uint8_t green;
uint8_t blue;
} RGBBacklightColor;
// use one type RGBBacklightColor for current_leds_settings and for static colors definition
static RGBBacklightColor current_led[] = {
{"LED0", 0, 0, 0},
{"LED1", 0, 0, 0},
{"LED2", 0, 0, 0},
};
static const RGBBacklightColor colors[] = { static const RGBBacklightColor colors[] = {
{"Orange", 255, 60, 0}, {"Orange", 255, 60, 0},
{"Yellow", 255, 144, 0}, {"Yellow", 255, 144, 0},
@@ -42,7 +57,7 @@ static const RGBBacklightColor colors[] = {
{"Pink", 255, 0, 127}, {"Pink", 255, 0, 127},
{"Red", 255, 0, 0}, {"Red", 255, 0, 0},
{"White", 254, 210, 200}, {"White", 254, 210, 200},
{"Custom", 0, 0, 0}, {"OFF", 0, 0, 0},
}; };
uint8_t rgb_backlight_get_color_count(void) { uint8_t rgb_backlight_get_color_count(void) {
@@ -54,39 +69,77 @@ const char* rgb_backlight_get_color_text(uint8_t index) {
} }
// use RECORD for acces to rgb service instance and update current colors by static // use RECORD for acces to rgb service instance and update current colors by static
void rgb_backlight_set_static_color(uint8_t index) { void rgb_backlight_set_led_static_color(uint8_t led, uint8_t index) {
RGBBacklightApp* app = furi_record_open(RECORD_RGB_BACKLIGHT); if(led < SK6805_get_led_count()) {
uint8_t r = colors[index].red;
uint8_t g = colors[index].green;
uint8_t b = colors[index].blue;
//if user select "custom" value then set current colors by custom values current_led[led].red = r;
if(index == 13) { current_led[led].green = g;
app->current_red = app->settings->custom_red; current_led[led].blue = b;
app->current_green = app->settings->custom_green;
app->current_blue = app->settings->custom_blue; SK6805_set_led_color(led, r, g, b);
} else {
app->current_red = colors[index].red;
app->current_green = colors[index].green;
app->current_blue = colors[index].blue;
} }
furi_record_close(RECORD_RGB_BACKLIGHT);
} }
// use RECORD for acces to rgb service instance and update current colors by custom // HSV to RGB based on
void rgb_backlight_set_custom_color(uint8_t red, uint8_t green, uint8_t blue) { // https://www.radiokot.ru/forum/viewtopic.php?p=3000181&ysclid=m88wvoz34w244644702
RGBBacklightApp* app = furi_record_open(RECORD_RGB_BACKLIGHT); // https://radiolaba.ru/microcotrollers/tsvetnaya-lampa.html#comment-1790
app->current_red = red; // https://alexgyver.ru/lessons/arduino-rgb/?ysclid=m88voflppa24464916
app->current_green = green; // led number (0-2), hue (0..255), sat (0..255), val (0...1)
app->current_blue = blue; void rgb_backlight_set_led_custom_hsv_color(uint8_t led, uint16_t hue, uint8_t sat, float V) {
furi_record_close(RECORD_RGB_BACKLIGHT); // init value
float r = 1.0f;
float g = 1.0f;
float b = 1.0f;
// from (0..255) to (0..1)
float H = hue / 255.0f;
float S = sat / 255.0f;
uint8_t i = trunc(H * 6);
float f = H * 6 - i;
float p = V * (1 - S);
float q = V * (1 - f * S);
float t = V * (1 - (1 - f) * S);
switch(i) {
case 0:
r = V, g = t, b = p;
break;
case 1:
r = q, g = V, b = p;
break;
case 2:
r = p, g = V, b = t;
break;
case 3:
r = p, g = q, b = V;
break;
case 4:
r = t, g = p, b = V;
break;
case 5:
r = V, g = p, b = q;
break;
}
// from (0..1) to (0..255)
current_led[led].red = r * 255;
current_led[led].green = g * 255;
current_led[led].blue = b * 255;
} }
// use RECORD for acces to rgb service instance, use current_* colors and update backlight // use RECORD for acces to rgb service instance, set current_* colors to led and update backlight
void rgb_backlight_update(float brightness) { void rgb_backlight_update(float brightness) {
RGBBacklightApp* app = furi_record_open(RECORD_RGB_BACKLIGHT); RGBBacklightApp* app = furi_record_open(RECORD_RGB_BACKLIGHT);
if(app->settings->rgb_mod_installed) {
if(app->settings->rgb_backlight_installed) {
for(uint8_t i = 0; i < SK6805_get_led_count(); i++) { for(uint8_t i = 0; i < SK6805_get_led_count(); i++) {
uint8_t r = app->current_red * (brightness / 1.0f); uint8_t r = current_led[i].red * (brightness * 1.0f);
uint8_t g = app->current_green * (brightness / 1.0f); uint8_t g = current_led[i].green * (brightness * 1.0f);
uint8_t b = app->current_blue * (brightness / 1.0f); uint8_t b = current_led[i].blue * (brightness * 1.0f);
SK6805_set_led_color(i, r, g, b); SK6805_set_led_color(i, r, g, b);
} }
SK6805_update(); SK6805_update();
@@ -94,90 +147,73 @@ void rgb_backlight_update(float brightness) {
furi_record_close(RECORD_RGB_BACKLIGHT); furi_record_close(RECORD_RGB_BACKLIGHT);
} }
//start furi timer for rainbow // start furi timer for rainbow
void rainbow_timer_start(RGBBacklightApp* app) { void rainbow_timer_start(RGBBacklightApp* app) {
furi_timer_start(app->rainbow_timer, furi_ms_to_ticks(app->settings->rainbow_speed_ms)); furi_timer_start(app->rainbow_timer, furi_ms_to_ticks(app->settings->rainbow_speed_ms));
} }
//stop furi timer for rainbow // stop furi timer for rainbow
void rainbow_timer_stop(RGBBacklightApp* app) { void rainbow_timer_stop(RGBBacklightApp* app) {
furi_timer_stop(app->rainbow_timer); furi_timer_stop(app->rainbow_timer);
} }
// if rgb_mod_installed then apply rainbow colors to backlight and start/restart/stop rainbow_timer // if rgb_backlight_installed then apply rainbow colors to backlight and start/restart/stop rainbow_timer
void rainbow_timer_starter(RGBBacklightApp* app) { void rainbow_timer_starter(RGBBacklightApp* app) {
if((app->settings->rainbow_mode > 0) && (app->settings->rgb_mod_installed)) { if((app->settings->rainbow_mode > 0) && (app->settings->rgb_backlight_installed)) {
rainbow_timer_start(app); rainbow_timer_start(app);
} else {
if(furi_timer_is_running(app->rainbow_timer)) {
rainbow_timer_stop(app);
}
} }
} }
static void rainbow_timer_callback(void* context) { static void rainbow_timer_callback(void* context) {
furi_assert(context); furi_assert(context);
RGBBacklightApp* app = context; RGBBacklightApp* app = context;
// if rainbow_mode is rainbow do rainbow effect if(app->settings->rgb_backlight_installed) {
if(app->settings->rainbow_mode == 1) { app->rainbow_hue += app->settings->rainbow_step;
switch(app->rainbow_stage) { if(app->rainbow_hue > 254) {
// from red to yellow (255,0,0) - (255,255,0) app->rainbow_hue = 0;
}
uint8_t wide = app->settings->rainbow_wide;
switch(app->settings->rainbow_mode) {
//rainbow mode
case 1: case 1:
app->current_green += app->settings->rainbow_step; for(uint8_t i = 0; i < SK6805_get_led_count(); i++) {
if(app->current_green >= 255) { rgb_backlight_set_led_custom_hsv_color(
app->current_green = 255; i,
app->rainbow_stage++; app->rainbow_hue,
app->settings->rainbow_saturation,
app->settings->brightness);
} }
break; break;
// yellow to green (255,255,0) - (0,255,0)
//wave mode
case 2: case 2:
app->current_red -= app->settings->rainbow_step; uint16_t j = app->rainbow_hue + wide;
if(app->current_red <= 0) { uint16_t k = app->rainbow_hue + wide * 2;
app->current_red = 0;
app->rainbow_stage++; if(app->rainbow_hue > (254 - wide)) {
j = j - 255;
} }
break; if(app->rainbow_hue > (254 - wide * 2)) {
// from green to light blue (0,255,0) - (0,255,255) k = k - 255;
case 3:
app->current_blue += app->settings->rainbow_step;
if(app->current_blue >= 255) {
app->current_blue = 255;
app->rainbow_stage++;
}
break;
//from light blue to blue (0,255,255) - (0,0,255)
case 4:
app->current_green -= app->settings->rainbow_step;
if(app->current_green <= 0) {
app->current_green = 0;
app->rainbow_stage++;
}
break;
//from blue to violet (0,0,255) - (255,0,255)
case 5:
app->current_red += app->settings->rainbow_step;
if(app->current_red >= 255) {
app->current_red = 255;
app->rainbow_stage++;
}
break;
//from violet to red (255,0,255) - (255,0,0)
case 6:
app->current_blue -= app->settings->rainbow_step;
if(app->current_blue <= 0) {
app->current_blue = 0;
app->rainbow_stage = 1;
} }
rgb_backlight_set_led_custom_hsv_color(
0, app->rainbow_hue, app->settings->rainbow_saturation, app->settings->brightness);
rgb_backlight_set_led_custom_hsv_color(
1, j, app->settings->rainbow_saturation, app->settings->brightness);
rgb_backlight_set_led_custom_hsv_color(
2, k, app->settings->rainbow_saturation, app->settings->brightness);
break; break;
default: default:
break; break;
} }
rgb_backlight_update(app->settings->brightness); rgb_backlight_update(app->settings->brightness);
} }
// if rainbow_mode is ..... do another effect
// if(app->settings.rainbow_mode == ...) {
// }
} }
int32_t rgb_backlight_srv(void* p) { int32_t rgb_backlight_srv(void* p) {
@@ -187,47 +223,41 @@ int32_t rgb_backlight_srv(void* p) {
// allocate memory and create RECORD for access to app structure from outside // allocate memory and create RECORD for access to app structure from outside
RGBBacklightApp* app = malloc(sizeof(RGBBacklightApp)); RGBBacklightApp* app = malloc(sizeof(RGBBacklightApp));
//define rainbow_timer and they callback // define rainbow_timer and they callback
app->rainbow_timer = furi_timer_alloc(rainbow_timer_callback, FuriTimerTypePeriodic, app); app->rainbow_timer = furi_timer_alloc(rainbow_timer_callback, FuriTimerTypePeriodic, app);
// settings load or create default // settings load or create default
app->settings = malloc(sizeof(RGBBacklightSettings)); app->settings = malloc(sizeof(RGBBacklightSettings));
rgb_backlight_settings_load(app->settings); rgb_backlight_settings_load(app->settings);
// Init app variables app->rainbow_hue = 1;
app->rainbow_stage = 1;
furi_record_create(RECORD_RGB_BACKLIGHT, app); furi_record_create(RECORD_RGB_BACKLIGHT, app);
// if rgb mod installed - start rainbow or set static color from settings (default index = 0) // if rgb_backlight_installed then start rainbow or set leds colors from saved settings (default index = 0)
if(app->settings->rgb_mod_installed) { if(app->settings->rgb_backlight_installed) {
if(app->settings->rainbow_mode > 0) { if(app->settings->rainbow_mode > 0) {
rainbow_timer_starter(app); rainbow_timer_start(app);
} else { } else {
rgb_backlight_set_static_color(app->settings->static_color_index); rgb_backlight_set_led_static_color(2, app->settings->led_2_color_index);
rgb_backlight_set_led_static_color(1, app->settings->led_1_color_index);
rgb_backlight_set_led_static_color(0, app->settings->led_0_color_index);
rgb_backlight_update(app->settings->brightness); rgb_backlight_update(app->settings->brightness);
} }
// if rgb mod not installed - set default static orange color (index=0) // if rgb_backlight not installed then set default static orange color(index=0) to all leds (0-2) and force light on
} else { } else {
//rgb_backlight_set_static_color(0); rgb_backlight_set_led_static_color(2, 0);
//rgb_backlight_update(app->settings->brightness); rgb_backlight_set_led_static_color(1, 0);
rgb_backlight_set_static_color(0); rgb_backlight_set_led_static_color(0, 0);
for(uint8_t i = 0; i < SK6805_get_led_count(); i++) {
uint8_t r = app->current_red * (1.0f / 1.0f);
uint8_t g = app->current_green * (1.0f / 1.0f);
uint8_t b = app->current_blue * (1.0f / 1.0f);
SK6805_set_led_color(i, r, g, b);
}
SK6805_update(); SK6805_update();
} }
while(1) { while(1) {
// place for message queue and other future options
furi_delay_ms(5000); furi_delay_ms(5000);
if(app->settings->rgb_mod_installed) { if(app->settings->rgb_backlight_installed) {
FURI_LOG_D(TAG, "Mod is enabled - serivce is running"); FURI_LOG_D(TAG, "RGB backlight enabled - serivce is running");
} else { } else {
FURI_LOG_D(TAG, "Mod is DISABLED - serivce is running"); FURI_LOG_D(TAG, "RGB backlight DISABLED - serivce is running");
} }
} }
return 0; return 0;

69
applications/services/rgb_backlight/rgb_backlight.h
View File

@@ -26,34 +26,71 @@
extern "C" { extern "C" {
#endif #endif
typedef struct {
char* name;
uint8_t red;
uint8_t green;
uint8_t blue;
} RGBBacklightColor;
typedef struct { typedef struct {
FuriTimer* rainbow_timer; FuriTimer* rainbow_timer;
uint16_t rainbow_hue;
int16_t current_red; uint8_t rainbow_red;
int16_t current_green; uint8_t rainbow_green;
int16_t current_blue; uint8_t rainbow_blue;
uint8_t rainbow_stage;
RGBBacklightSettings* settings; RGBBacklightSettings* settings;
} RGBBacklightApp; } RGBBacklightApp;
#define RECORD_RGB_BACKLIGHT "rgb_backlight" #define RECORD_RGB_BACKLIGHT "rgb_backlight"
/** Update leds colors from current_led[i].color and selected bright
*
* @param brightness - Brightness 0..1
* @return
*/
void rgb_backlight_update(float brightness); void rgb_backlight_update(float brightness);
void rgb_backlight_set_custom_color(uint8_t red, uint8_t green, uint8_t blue);
void rgb_backlight_set_static_color(uint8_t index); /** Set current_led[i].color for one led by static color index
*
* @param led - Led number (0..2)
* @param index - Static color index number
* @return
*/
void rgb_backlight_set_led_static_color(uint8_t led, uint8_t index);
/** Stop rainbow timer
*
* @param app - Instance of RGBBacklightApp from FURI RECORD
* @return
*/
void rainbow_timer_stop(RGBBacklightApp* app); void rainbow_timer_stop(RGBBacklightApp* app);
/** Start rainbow timer
*
* @param app - Instance of RGBBacklightApp from FURI RECORD
* @return
*/
/** Start rainbow timer
*
* @param app - Instance of RGBBacklightApp from FURI RECORD
* @return
*/
void rainbow_timer_start(RGBBacklightApp* app); void rainbow_timer_start(RGBBacklightApp* app);
/** Start rainbow timer only if all conditions meet (rgb_backlight_installed && rainbow ON)
*
* @param app - Instance of RGBBacklightApp from FURI RECORD
* @return
*/
void rainbow_timer_starter(RGBBacklightApp* app); void rainbow_timer_starter(RGBBacklightApp* app);
/** Get name of static color by index
*
* @param index - Static colors index number
* @return - color name
*/
const char* rgb_backlight_get_color_text(uint8_t index); const char* rgb_backlight_get_color_text(uint8_t index);
/** Get static colors count
*
* @param
* @return - colors count
*/
uint8_t rgb_backlight_get_color_count(void); uint8_t rgb_backlight_get_color_count(void);
#ifdef __cplusplus #ifdef __cplusplus

19
applications/services/rgb_backlight/rgb_backlight_settings.c
View File

@@ -10,21 +10,26 @@
#define RGB_BACKLIGHT_SETTINGS_MAGIC (0x30) #define RGB_BACKLIGHT_SETTINGS_MAGIC (0x30)
#define RGB_BACKLIGHT_SETTINGS_VER_PREV (0) // Previous version number #define RGB_BACKLIGHT_SETTINGS_VER_PREV (0) // Previous version number
#define RGB_BACKLIGHT_SETTINGS_VER (1) // New version number #define RGB_BACKLIGHT_SETTINGS_VER (1) // Current version number
//pervious settings must be copyed from previous rgb_backlight_settings.h file //pervious settings must be copyed from previous rgb_backlight_settings.h file
typedef struct { typedef struct {
//Common settings
uint8_t version; uint8_t version;
bool rgb_mod_installed; uint8_t rgb_backlight_installed;
float brightness;
uint8_t static_color_index; // static gradient mode settings
uint8_t custom_r; uint8_t led_2_color_index;
uint8_t custom_g; uint8_t led_1_color_index;
uint8_t custom_b; uint8_t led_0_color_index;
// rainbow mode setings
uint32_t rainbow_mode; uint32_t rainbow_mode;
uint32_t rainbow_speed_ms; uint32_t rainbow_speed_ms;
uint16_t rainbow_step; uint16_t rainbow_step;
uint8_t rainbow_saturation;
uint8_t rainbow_wide;
} RGBBacklightSettingsPrevious; } RGBBacklightSettingsPrevious;
void rgb_backlight_settings_load(RGBBacklightSettings* settings) { void rgb_backlight_settings_load(RGBBacklightSettings* settings) {
@@ -79,6 +84,8 @@ void rgb_backlight_settings_load(RGBBacklightSettings* settings) {
settings->brightness = 1.0f; settings->brightness = 1.0f;
settings->rainbow_speed_ms = 100; settings->rainbow_speed_ms = 100;
settings->rainbow_step = 1; settings->rainbow_step = 1;
settings->rainbow_saturation = 255;
settings->rainbow_wide = 50;
rgb_backlight_settings_save(settings); rgb_backlight_settings_save(settings);
} }
} }

16
applications/services/rgb_backlight/rgb_backlight_settings.h
View File

@@ -4,18 +4,22 @@
#include <stdbool.h> #include <stdbool.h>
typedef struct { typedef struct {
//Common settings
uint8_t version; uint8_t version;
bool rgb_mod_installed; uint8_t rgb_backlight_installed;
uint8_t static_color_index;
uint8_t custom_red;
uint8_t custom_green;
uint8_t custom_blue;
float brightness; float brightness;
// static gradient mode settings
uint8_t led_2_color_index;
uint8_t led_1_color_index;
uint8_t led_0_color_index;
// rainbow mode setings
uint32_t rainbow_mode; uint32_t rainbow_mode;
uint32_t rainbow_speed_ms; uint32_t rainbow_speed_ms;
uint16_t rainbow_step; uint16_t rainbow_step;
uint8_t rainbow_saturation;
uint8_t rainbow_wide;
} RGBBacklightSettings; } RGBBacklightSettings;

520
applications/settings/notification_settings/notification_settings_app.c
View File

@@ -16,8 +16,6 @@ typedef struct {
VariableItemList* variable_item_list_rgb; VariableItemList* variable_item_list_rgb;
} NotificationAppSettings; } NotificationAppSettings;
static VariableItem* temp_item;
static const NotificationSequence sequence_note_c = { static const NotificationSequence sequence_note_c = {
&message_note_c5, &message_note_c5,
&message_delay_100, &message_delay_100,
@@ -110,43 +108,72 @@ const char* const vibro_text[VIBRO_COUNT] = {
const bool vibro_value[VIBRO_COUNT] = {false, true}; const bool vibro_value[VIBRO_COUNT] = {false, true};
// --- RGB BACKLIGHT --- // --- RGB BACKLIGHT ---
#define RGB_MOD_INSTALLED_COUNT 2
const char* const rgb_mod_installed_text[RGB_MOD_INSTALLED_COUNT] = { #define RGB_BACKLIGHT_INSTALLED_COUNT 2
const char* const rgb_backlight_installed_text[RGB_BACKLIGHT_INSTALLED_COUNT] = {
"OFF", "OFF",
"ON", "ON",
}; };
const bool rgb_mod_installed_value[RGB_MOD_INSTALLED_COUNT] = {false, true}; const bool rgb_backlight_installed_value[RGB_BACKLIGHT_INSTALLED_COUNT] = {false, true};
#define RGB_MOD_RAINBOW_MODE_COUNT 2 #define RGB_BACKLIGHT_RAINBOW_MODE_COUNT 3
const char* const rgb_mod_rainbow_mode_text[RGB_MOD_RAINBOW_MODE_COUNT] = { const char* const rgb_backlight_rainbow_mode_text[RGB_BACKLIGHT_RAINBOW_MODE_COUNT] = {
"OFF", "OFF",
"Rainbow", "Rainbow",
"Wave",
}; };
const uint32_t rgb_mod_rainbow_mode_value[RGB_MOD_RAINBOW_MODE_COUNT] = {0, 1}; const uint32_t rgb_backlight_rainbow_mode_value[RGB_BACKLIGHT_RAINBOW_MODE_COUNT] = {0, 1, 2};
#define RGB_MOD_RAINBOW_SPEED_COUNT 20 #define RGB_BACKLIGHT_RAINBOW_SPEED_COUNT 10
const char* const rgb_mod_rainbow_speed_text[RGB_MOD_RAINBOW_SPEED_COUNT] = { const char* const rgb_backlight_rainbow_speed_text[RGB_BACKLIGHT_RAINBOW_SPEED_COUNT] = {
"0.1s", "0.2s", "0.3s", "0.4s", "0.5s", "0.6s", "0.7", "0.8", "0.9", "1s", "0.1s",
"1.1s", "1.2s", "1.3s", "1.4s", "1.5s", "1.6s", "1.7s", "1.8s", "1.9s", "2s"}; "0.2s",
const uint32_t rgb_mod_rainbow_speed_value[RGB_MOD_RAINBOW_SPEED_COUNT] = { "0.3s",
100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, "0.4s",
1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000}; "0.5s",
"0.6s",
"0.7",
"0.8",
"0.9",
"1s",
};
#define RGB_MOD_RAINBOW_STEP_COUNT 10 const uint32_t rgb_backlight_rainbow_speed_value[RGB_BACKLIGHT_RAINBOW_SPEED_COUNT] = {
const char* const rgb_mod_rainbow_step_text[RGB_MOD_RAINBOW_SPEED_COUNT] = { 100,
200,
300,
400,
500,
600,
700,
800,
900,
1000,
};
#define RGB_BACKLIGHT_RAINBOW_STEP_COUNT 3
const char* const rgb_backlight_rainbow_step_text[RGB_BACKLIGHT_RAINBOW_STEP_COUNT] = {
"1", "1",
"2", "2",
"3", "3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
}; };
const uint32_t rgb_mod_rainbow_step_value[RGB_MOD_RAINBOW_STEP_COUNT] = const uint32_t rgb_backlight_rainbow_step_value[RGB_BACKLIGHT_RAINBOW_STEP_COUNT] = {
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 1,
2,
3,
};
#define RGB_BACKLIGHT_RAINBOW_WIDE_COUNT 3
const char* const rgb_backlight_rainbow_wide_text[RGB_BACKLIGHT_RAINBOW_WIDE_COUNT] = {
"1",
"2",
"3",
};
const uint32_t rgb_backlight_rainbow_wide_value[RGB_BACKLIGHT_RAINBOW_WIDE_COUNT] = {
30,
40,
50,
};
typedef enum { typedef enum {
MainViewId, MainViewId,
@@ -172,7 +199,7 @@ static void backlight_changed(VariableItem* item) {
app->notification->settings.display_brightness = backlight_value[index]; app->notification->settings.display_brightness = backlight_value[index];
//--- RGB BACKLIGHT --- //--- RGB BACKLIGHT ---
//set selected brightness to current rgb backlight service settings and save settings // set selected brightness to current rgb backlight service settings and save settings
app->notification->rgb_srv->settings->brightness = backlight_value[index]; app->notification->rgb_srv->settings->brightness = backlight_value[index];
rgb_backlight_settings_save(app->notification->rgb_srv->settings); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
//--- RGB BACKLIGHT END --- //--- RGB BACKLIGHT END ---
@@ -228,161 +255,174 @@ static void vibro_changed(VariableItem* item) {
//--- RGB BACKLIGHT --- //--- RGB BACKLIGHT ---
static void rgb_mod_installed_changed(VariableItem* item) { static void rgb_backlight_installed_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item); NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item); uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_mod_installed_text[index]); variable_item_set_current_value_text(item, rgb_backlight_installed_text[index]);
app->notification->rgb_srv->settings->rgb_mod_installed = rgb_mod_installed_value[index]; app->notification->rgb_srv->settings->rgb_backlight_installed =
rgb_backlight_installed_value[index];
rgb_backlight_settings_save(app->notification->rgb_srv->settings); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
// Lock/Unlock rgb settings depent from rgb_mod_installed switch
// In case of user playing with rgb_backlight_installed swith:
// if user swith_off rgb_backlight_installed (but may be he have mod installed)
// then force set default orange color - defence from stupid.
if(index == 0) {
rgb_backlight_set_led_static_color(2, 0);
rgb_backlight_set_led_static_color(1, 0);
rgb_backlight_set_led_static_color(0, 0);
SK6805_update();
// start rainbow (if its Enabled) or set saved static colors if user swith_on rgb_backlight_installed switch
} else {
if(app->notification->rgb_srv->settings->rainbow_mode > 0) {
rainbow_timer_starter(app->notification->rgb_srv);
} else {
rgb_backlight_set_led_static_color(
2, app->notification->rgb_srv->settings->led_2_color_index);
rgb_backlight_set_led_static_color(
1, app->notification->rgb_srv->settings->led_1_color_index);
rgb_backlight_set_led_static_color(
0, app->notification->rgb_srv->settings->led_0_color_index);
rgb_backlight_update(app->notification->settings.display_brightness);
}
}
// Lock/Unlock all rgb settings depent from rgb_backlight_installed switch
int slide = 0; int slide = 0;
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) { if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
slide = 1; slide = 1;
} }
for(int i = slide; i < (slide + 7); i++) { for(int i = slide; i < (slide + 8); i++) {
VariableItem* t_item = variable_item_list_get(app->variable_item_list_rgb, i); VariableItem* t_item = variable_item_list_get(app->variable_item_list_rgb, i);
if(index == 0) { if(index == 0) {
variable_item_set_locked(t_item, true, "RGB MOD\nOFF!"); variable_item_set_locked(t_item, true, "RGB\nOFF!");
} else { } else {
variable_item_set_locked(t_item, false, "RGB MOD\nOFF!"); variable_item_set_locked(t_item, false, "RGB\nOFF!");
} }
} }
} }
static void rgb_mod_rainbow_changed(VariableItem* item) { static void led_2_color_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_mod_rainbow_mode_text[index]);
app->notification->rgb_srv->settings->rainbow_mode = rgb_mod_rainbow_mode_value[index];
rainbow_timer_starter(app->notification->rgb_srv);
rgb_backlight_settings_save(app->notification->rgb_srv->settings);
// Lock/Unlock color settings if rainbow mode Enabled/Disabled (0-3 index if debug off and 1-4 index if debug on)
int slide = 0;
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
slide = 1;
}
for(int i = slide; i < (slide + 4); i++) {
VariableItem* t_item = variable_item_list_get(app->variable_item_list_rgb, i);
if(index > 0) {
variable_item_set_locked(t_item, true, "Rainbow mode\nenabled!");
} else {
variable_item_set_locked(t_item, false, "Rainbow mode\nenabled!");
}
}
// restore saved rgb backlight settings if we switch_off rainbow mode
if(app->notification->rgb_srv->settings->rainbow_mode == 0) {
rgb_backlight_set_static_color(app->notification->rgb_srv->settings->static_color_index);
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
}
}
static void rgb_mod_rainbow_speed_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_mod_rainbow_speed_text[index]);
app->notification->rgb_srv->settings->rainbow_speed_ms = rgb_mod_rainbow_speed_value[index];
//save settings and restart timer with new speed value
rgb_backlight_settings_save(app->notification->rgb_srv->settings);
rainbow_timer_starter(app->notification->rgb_srv);
}
static void rgb_mod_rainbow_step_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_mod_rainbow_step_text[index]);
app->notification->rgb_srv->settings->rainbow_step = rgb_mod_rainbow_step_value[index];
rgb_backlight_settings_save(app->notification->rgb_srv->settings);
}
// Set rgb_backlight colors static and custom
static void color_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item); NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item); uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_backlight_get_color_text(index)); variable_item_set_current_value_text(item, rgb_backlight_get_color_text(index));
app->notification->rgb_srv->settings->static_color_index = index; app->notification->rgb_srv->settings->led_2_color_index = index;
rgb_backlight_set_static_color(index); // dont update screen color if rainbow timer working
rgb_backlight_update(app->notification->rgb_srv->settings->brightness); if(!furi_timer_is_running(app->notification->rgb_srv->rainbow_timer)) {
rgb_backlight_set_led_static_color(2, index);
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
}
rgb_backlight_settings_save(app->notification->rgb_srv->settings); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
} }
static void color_set_custom_red(VariableItem* item) { static void led_1_color_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item); NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item); uint8_t index = variable_item_get_current_value_index(item);
//Set custom red to settings and current color variable_item_set_current_value_text(item, rgb_backlight_get_color_text(index));
app->notification->rgb_srv->settings->custom_red = index; app->notification->rgb_srv->settings->led_1_color_index = index;
app->notification->rgb_srv->current_red = index;
app->notification->rgb_srv->settings->static_color_index = 13;
char valtext[4] = {}; // dont update screen color if rainbow timer working
snprintf(valtext, sizeof(valtext), "%d", index); if(!furi_timer_is_running(app->notification->rgb_srv->rainbow_timer)) {
variable_item_set_current_value_text(item, valtext); rgb_backlight_set_led_static_color(1, index);
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
}
// Set to custom color explicitly
variable_item_set_current_value_index(temp_item, 13);
variable_item_set_current_value_text(temp_item, rgb_backlight_get_color_text(13));
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
rgb_backlight_settings_save(app->notification->rgb_srv->settings); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
} }
static void color_set_custom_green(VariableItem* item) {
static void led_0_color_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item); NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item); uint8_t index = variable_item_get_current_value_index(item);
//Set custom green to settings and current color variable_item_set_current_value_text(item, rgb_backlight_get_color_text(index));
app->notification->rgb_srv->settings->custom_green = index; app->notification->rgb_srv->settings->led_0_color_index = index;
app->notification->rgb_srv->current_green = index;
app->notification->rgb_srv->settings->static_color_index = 13;
char valtext[4] = {}; // dont update screen color if rainbow timer working
snprintf(valtext, sizeof(valtext), "%d", index); if(!furi_timer_is_running(app->notification->rgb_srv->rainbow_timer)) {
variable_item_set_current_value_text(item, valtext); rgb_backlight_set_led_static_color(0, index);
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
}
// Set to custom color explicitly
variable_item_set_current_value_index(temp_item, 13);
variable_item_set_current_value_text(temp_item, rgb_backlight_get_color_text(13));
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
rgb_backlight_settings_save(app->notification->rgb_srv->settings); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
} }
static void color_set_custom_blue(VariableItem* item) {
static void rgb_backlight_rainbow_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item); NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item); uint8_t index = variable_item_get_current_value_index(item);
//Set custom blue to settings and current color variable_item_set_current_value_text(item, rgb_backlight_rainbow_mode_text[index]);
app->notification->rgb_srv->settings->custom_blue = index; app->notification->rgb_srv->settings->rainbow_mode = rgb_backlight_rainbow_mode_value[index];
app->notification->rgb_srv->current_blue = index;
app->notification->rgb_srv->settings->static_color_index = 13;
char valtext[4] = {}; rainbow_timer_starter(app->notification->rgb_srv);
snprintf(valtext, sizeof(valtext), "%d", index); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
variable_item_set_current_value_text(item, valtext);
// Set to custom color explicitly // restore saved rgb backlight settings if we switch_off rainbow mode
variable_item_set_current_value_index(temp_item, 13); if(app->notification->rgb_srv->settings->rainbow_mode == 0) {
variable_item_set_current_value_text(temp_item, rgb_backlight_get_color_text(13)); rgb_backlight_set_led_static_color(
2, app->notification->rgb_srv->settings->led_2_color_index);
rgb_backlight_set_led_static_color(
1, app->notification->rgb_srv->settings->led_1_color_index);
rgb_backlight_set_led_static_color(
0, app->notification->rgb_srv->settings->led_0_color_index);
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
}
}
static void rgb_backlight_rainbow_speed_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_backlight_rainbow_speed_text[index]);
app->notification->rgb_srv->settings->rainbow_speed_ms =
rgb_backlight_rainbow_speed_value[index];
// save settings and restart timer with new speed value
rgb_backlight_settings_save(app->notification->rgb_srv->settings);
rainbow_timer_starter(app->notification->rgb_srv);
}
static void rgb_backlight_rainbow_step_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_backlight_rainbow_step_text[index]);
app->notification->rgb_srv->settings->rainbow_step = rgb_backlight_rainbow_step_value[index];
rgb_backlight_update(app->notification->rgb_srv->settings->brightness);
rgb_backlight_settings_save(app->notification->rgb_srv->settings); rgb_backlight_settings_save(app->notification->rgb_srv->settings);
} }
// open rgb_settings_view if user press OK on first (index=0) menu string and (debug mode or rgb_mod_install is true) static void rgb_backlight_rainbow_saturation_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
// saturation must be 1..255, so we do (0..254)+1
uint8_t index = variable_item_get_current_value_index(item) + 1;
char valtext[4] = {};
snprintf(valtext, sizeof(valtext), "%d", index);
variable_item_set_current_value_text(item, valtext);
app->notification->rgb_srv->settings->rainbow_saturation = index;
rgb_backlight_settings_save(app->notification->rgb_srv->settings);
}
static void rgb_backlight_rainbow_wide_changed(VariableItem* item) {
NotificationAppSettings* app = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, rgb_backlight_rainbow_wide_text[index]);
app->notification->rgb_srv->settings->rainbow_wide = rgb_backlight_rainbow_wide_value[index];
// save settings and restart timer with new speed value
rgb_backlight_settings_save(app->notification->rgb_srv->settings);
rainbow_timer_starter(app->notification->rgb_srv);
}
// open rgb_settings_view if user press OK on first (index=0) menu string and (debug mode or rgb_backlight_installed is true)
void variable_item_list_enter_callback(void* context, uint32_t index) { void variable_item_list_enter_callback(void* context, uint32_t index) {
UNUSED(context); UNUSED(context);
NotificationAppSettings* app = context; NotificationAppSettings* app = context;
if(((app->notification->rgb_srv->settings->rgb_mod_installed) || if(((app->notification->rgb_srv->settings->rgb_backlight_installed) ||
(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug))) && (furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug))) &&
(index == 0)) { (index == 0)) {
view_dispatcher_switch_to_view(app->view_dispatcher, RGBViewId); view_dispatcher_switch_to_view(app->view_dispatcher, RGBViewId);
@@ -420,10 +460,10 @@ static NotificationAppSettings* alloc_settings(void) {
variable_item_list_set_enter_callback( variable_item_list_set_enter_callback(
app->variable_item_list, variable_item_list_enter_callback, app); app->variable_item_list, variable_item_list_enter_callback, app);
//Show RGB settings only when debug_mode or rgb_mod_installed is active // Show RGB settings only when debug_mode or rgb_backlight_installed is active
if((app->notification->rgb_srv->settings->rgb_mod_installed) || if((app->notification->rgb_srv->settings->rgb_backlight_installed) ||
(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug))) { (furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug))) {
item = variable_item_list_add(app->variable_item_list, "RGB mod settings", 0, NULL, app); item = variable_item_list_add(app->variable_item_list, "RGB settings", 0, NULL, app);
} }
//--- RGB BACKLIGHT END --- //--- RGB BACKLIGHT END ---
@@ -484,125 +524,159 @@ static NotificationAppSettings* alloc_settings(void) {
} }
//--- RGB BACKLIGHT --- //--- RGB BACKLIGHT ---
app->variable_item_list_rgb = variable_item_list_alloc(); app->variable_item_list_rgb = variable_item_list_alloc();
View* view_rgb = variable_item_list_get_view(app->variable_item_list_rgb); View* view_rgb = variable_item_list_get_view(app->variable_item_list_rgb);
// set callback for OK pressed in rgb_settings_menu // set callback for exit from rgb_settings_menu
view_set_previous_callback(view_rgb, notification_app_rgb_settings_exit); view_set_previous_callback(view_rgb, notification_app_rgb_settings_exit);
// Show RGB_MOD_Installed_Swith only in Debug mode // Show rgb_backlight_installed swith only in Debug mode
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) { if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
item = variable_item_list_add( item = variable_item_list_add(
app->variable_item_list_rgb, app->variable_item_list_rgb,
"RGB MOD Installed", "RGB backlight installed",
RGB_MOD_INSTALLED_COUNT, RGB_BACKLIGHT_INSTALLED_COUNT,
rgb_mod_installed_changed, rgb_backlight_installed_changed,
app); app);
value_index = value_index_bool( value_index = value_index_bool(
app->notification->rgb_srv->settings->rgb_mod_installed, app->notification->rgb_srv->settings->rgb_backlight_installed,
rgb_mod_installed_value, rgb_backlight_installed_value,
RGB_MOD_INSTALLED_COUNT); RGB_BACKLIGHT_INSTALLED_COUNT);
variable_item_set_current_value_index(item, value_index); variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_mod_installed_text[value_index]); variable_item_set_current_value_text(item, rgb_backlight_installed_text[value_index]);
} }
// Static Colors settings // We (humans) are numbering LEDs from left to right as 1..3, but hardware have another order from right to left 2..0
// led_1 color
item = variable_item_list_add( item = variable_item_list_add(
app->variable_item_list_rgb, app->variable_item_list_rgb,
"LCD Color", "LED 1 Color",
rgb_backlight_get_color_count(), rgb_backlight_get_color_count(),
color_changed, led_2_color_changed,
app); app);
value_index = app->notification->rgb_srv->settings->static_color_index; value_index = app->notification->rgb_srv->settings->led_2_color_index;
variable_item_set_current_value_index(item, value_index); variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_backlight_get_color_text(value_index)); variable_item_set_current_value_text(item, rgb_backlight_get_color_text(value_index));
variable_item_set_locked( variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rainbow_mode > 0), "Rainbow mode\nenabled!"); item,
variable_item_set_locked( (app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!"); "RGB MOD \nOFF!");
temp_item = item; // led_2 color
// Custom Color - REFACTOR THIS
item = variable_item_list_add( item = variable_item_list_add(
app->variable_item_list_rgb, "Custom Red", 255, color_set_custom_red, app); app->variable_item_list_rgb,
value_index = app->notification->rgb_srv->settings->custom_red; "LED 2 Color",
rgb_backlight_get_color_count(),
led_1_color_changed,
app);
value_index = app->notification->rgb_srv->settings->led_1_color_index;
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_backlight_get_color_text(value_index));
variable_item_set_locked(
item,
(app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
"RGB MOD \nOFF!");
// led 3 color
item = variable_item_list_add(
app->variable_item_list_rgb,
"LED 3 Color",
rgb_backlight_get_color_count(),
led_0_color_changed,
app);
value_index = app->notification->rgb_srv->settings->led_0_color_index;
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_backlight_get_color_text(value_index));
variable_item_set_locked(
item,
(app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
"RGB MOD \nOFF!");
// Rainbow mode
item = variable_item_list_add(
app->variable_item_list_rgb,
"Rainbow mode",
RGB_BACKLIGHT_RAINBOW_MODE_COUNT,
rgb_backlight_rainbow_changed,
app);
value_index = value_index_uint32(
app->notification->rgb_srv->settings->rainbow_mode,
rgb_backlight_rainbow_mode_value,
RGB_BACKLIGHT_RAINBOW_MODE_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_backlight_rainbow_mode_text[value_index]);
variable_item_set_locked(
item,
(app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
"RGB MOD \nOFF!");
item = variable_item_list_add(
app->variable_item_list_rgb,
"Rainbow speed",
RGB_BACKLIGHT_RAINBOW_SPEED_COUNT,
rgb_backlight_rainbow_speed_changed,
app);
value_index = value_index_uint32(
app->notification->rgb_srv->settings->rainbow_speed_ms,
rgb_backlight_rainbow_speed_value,
RGB_BACKLIGHT_RAINBOW_SPEED_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_backlight_rainbow_speed_text[value_index]);
variable_item_set_locked(
item,
(app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
"RGB MOD \nOFF!");
item = variable_item_list_add(
app->variable_item_list_rgb,
"Rainbow step",
RGB_BACKLIGHT_RAINBOW_STEP_COUNT,
rgb_backlight_rainbow_step_changed,
app);
value_index = value_index_uint32(
app->notification->rgb_srv->settings->rainbow_step,
rgb_backlight_rainbow_step_value,
RGB_BACKLIGHT_RAINBOW_STEP_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_backlight_rainbow_step_text[value_index]);
variable_item_set_locked(
item,
(app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
"RGB MOD \nOFF!");
item = variable_item_list_add(
app->variable_item_list_rgb,
"Saturation",
255,
rgb_backlight_rainbow_saturation_changed,
app);
value_index = app->notification->rgb_srv->settings->rainbow_saturation;
variable_item_set_current_value_index(item, value_index); variable_item_set_current_value_index(item, value_index);
char valtext[4] = {}; char valtext[4] = {};
snprintf(valtext, sizeof(valtext), "%d", value_index); snprintf(valtext, sizeof(valtext), "%d", value_index);
variable_item_set_current_value_text(item, valtext); variable_item_set_current_value_text(item, valtext);
variable_item_set_locked( variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rainbow_mode > 0), "Rainbow mode\nenabled!"); item,
variable_item_set_locked( (app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!"); "RGB MOD \nOFF!");
item = variable_item_list_add(
app->variable_item_list_rgb, "Custom Green", 255, color_set_custom_green, app);
value_index = app->notification->rgb_srv->settings->custom_green;
variable_item_set_current_value_index(item, value_index);
snprintf(valtext, sizeof(valtext), "%d", value_index);
variable_item_set_current_value_text(item, valtext);
variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rainbow_mode > 0), "Rainbow mode\nenabled!");
variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!");
item = variable_item_list_add(
app->variable_item_list_rgb, "Custom Blue", 255, color_set_custom_blue, app);
value_index = app->notification->rgb_srv->settings->custom_blue;
variable_item_set_current_value_index(item, value_index);
snprintf(valtext, sizeof(valtext), "%d", value_index);
variable_item_set_current_value_text(item, valtext);
variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rainbow_mode > 0), "Rainbow mode\nenabled!");
variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!");
// Rainbow (based on Willy-JL idea) settings
item = variable_item_list_add(
app->variable_item_list_rgb,
"Rainbow mode",
RGB_MOD_RAINBOW_MODE_COUNT,
rgb_mod_rainbow_changed,
app);
value_index = value_index_uint32(
app->notification->rgb_srv->settings->rainbow_mode,
rgb_mod_rainbow_mode_value,
RGB_MOD_RAINBOW_MODE_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_mod_rainbow_mode_text[value_index]);
variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!");
item = variable_item_list_add( item = variable_item_list_add(
app->variable_item_list_rgb, app->variable_item_list_rgb,
"Rainbow speed", "Wave wide",
RGB_MOD_RAINBOW_SPEED_COUNT, RGB_BACKLIGHT_RAINBOW_WIDE_COUNT,
rgb_mod_rainbow_speed_changed, rgb_backlight_rainbow_wide_changed,
app); app);
value_index = value_index_uint32( value_index = value_index_uint32(
app->notification->rgb_srv->settings->rainbow_speed_ms, app->notification->rgb_srv->settings->rainbow_wide,
rgb_mod_rainbow_speed_value, rgb_backlight_rainbow_wide_value,
RGB_MOD_RAINBOW_SPEED_COUNT); RGB_BACKLIGHT_RAINBOW_WIDE_COUNT);
variable_item_set_current_value_index(item, value_index); variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_mod_rainbow_speed_text[value_index]); variable_item_set_current_value_text(item, rgb_backlight_rainbow_wide_text[value_index]);
variable_item_set_locked( variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!"); item,
(app->notification->rgb_srv->settings->rgb_backlight_installed == 0),
item = variable_item_list_add( "RGB MOD \nOFF!");
app->variable_item_list_rgb,
"Rainbow step",
RGB_MOD_RAINBOW_STEP_COUNT,
rgb_mod_rainbow_step_changed,
app);
value_index = value_index_uint32(
app->notification->rgb_srv->settings->rainbow_step,
rgb_mod_rainbow_step_value,
RGB_MOD_RAINBOW_SPEED_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, rgb_mod_rainbow_step_text[value_index]);
variable_item_set_locked(
item, (app->notification->rgb_srv->settings->rgb_mod_installed == 0), "RGB MOD \nOFF!");
//--- RGB BACKLIGHT END --- //--- RGB BACKLIGHT END ---
@@ -632,8 +706,8 @@ int32_t notification_settings_app(void* p) {
view_dispatcher_run(app->view_dispatcher); view_dispatcher_run(app->view_dispatcher);
notification_message_save_settings(app->notification); notification_message_save_settings(app->notification);
// Automaticaly switch_off debug_mode when user exit from settings with enabled rgb_mod_installed // Automaticaly switch_off debug_mode when user exit from settings with enabled rgb_backlight_installed
// if(app->notification->settings.rgb_mod_installed) { // if(app->notification->settings.rgb_backlight_installed) {
// furi_hal_rtc_reset_flag(FuriHalRtcFlagDebug); // furi_hal_rtc_reset_flag(FuriHalRtcFlagDebug);
// } // }

5
targets/f7/api_symbols.csv
View File

@@ -1,5 +1,5 @@
entry,status,name,type,params entry,status,name,type,params
Version,+,83.1,, Version,+,83.2,,
Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,, Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
Header,+,applications/services/bt/bt_service/bt.h,, Header,+,applications/services/bt/bt_service/bt.h,,
Header,+,applications/services/bt/bt_service/bt_keys_storage.h,, Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
@@ -3148,8 +3148,7 @@ Function,-,renameat,int,"int, const char*, int, const char*"
Function,-,rewind,void,FILE* Function,-,rewind,void,FILE*
Function,+,rgb_backlight_get_color_count,uint8_t, Function,+,rgb_backlight_get_color_count,uint8_t,
Function,+,rgb_backlight_get_color_text,const char*,uint8_t Function,+,rgb_backlight_get_color_text,const char*,uint8_t
Function,+,rgb_backlight_set_custom_color,void,"uint8_t, uint8_t, uint8_t" Function,+,rgb_backlight_set_led_static_color,void,"uint8_t, uint8_t"
Function,+,rgb_backlight_set_static_color,void,uint8_t
Function,+,rgb_backlight_settings_load,void,RGBBacklightSettings* Function,+,rgb_backlight_settings_load,void,RGBBacklightSettings*
Function,+,rgb_backlight_settings_save,void,const RGBBacklightSettings* Function,+,rgb_backlight_settings_save,void,const RGBBacklightSettings*
Function,+,rgb_backlight_update,void,float Function,+,rgb_backlight_update,void,float
1 entry status name type params
2 Version + 83.1 83.2
3 Header + applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h
4 Header + applications/services/bt/bt_service/bt.h
5 Header + applications/services/bt/bt_service/bt_keys_storage.h
3148 Function - rewind void FILE*
3149 Function + rgb_backlight_get_color_count uint8_t
3150 Function + rgb_backlight_get_color_text const char* uint8_t
3151 Function + rgb_backlight_set_custom_color rgb_backlight_set_led_static_color void uint8_t, uint8_t, uint8_t uint8_t, uint8_t
Function + rgb_backlight_set_static_color void uint8_t
3152 Function + rgb_backlight_settings_load void RGBBacklightSettings*
3153 Function + rgb_backlight_settings_save void const RGBBacklightSettings*
3154 Function + rgb_backlight_update void float