diff options
Diffstat (limited to 'quantum/led_matrix.c')
-rw-r--r-- | quantum/led_matrix.c | 289 |
1 files changed, 157 insertions, 132 deletions
diff --git a/quantum/led_matrix.c b/quantum/led_matrix.c index 4f1f06c7a..4f05109b1 100644 --- a/quantum/led_matrix.c +++ b/quantum/led_matrix.c | |||
@@ -17,17 +17,15 @@ | |||
17 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | 17 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
18 | */ | 18 | */ |
19 | 19 | ||
20 | #include <stdint.h> | ||
21 | #include <stdbool.h> | ||
22 | #include "quantum.h" | ||
23 | #include "led_matrix.h" | 20 | #include "led_matrix.h" |
24 | #include "progmem.h" | 21 | #include "progmem.h" |
25 | #include "config.h" | 22 | #include "config.h" |
26 | #include "eeprom.h" | 23 | #include "eeprom.h" |
27 | #include <string.h> | 24 | #include <string.h> |
28 | #include <math.h> | 25 | #include <math.h> |
26 | #include "led_tables.h" | ||
29 | 27 | ||
30 | led_eeconfig_t led_matrix_eeconfig; | 28 | #include <lib/lib8tion/lib8tion.h> |
31 | 29 | ||
32 | #ifndef MAX | 30 | #ifndef MAX |
33 | # define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) | 31 | # define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) |
@@ -37,23 +35,46 @@ led_eeconfig_t led_matrix_eeconfig; | |||
37 | # define MIN(a, b) ((a) < (b) ? (a) : (b)) | 35 | # define MIN(a, b) ((a) < (b) ? (a) : (b)) |
38 | #endif | 36 | #endif |
39 | 37 | ||
40 | #ifndef LED_DISABLE_AFTER_TIMEOUT | 38 | #if defined(LED_DISABLE_AFTER_TIMEOUT) && !defined(LED_DISABLE_TIMEOUT) |
41 | # define LED_DISABLE_AFTER_TIMEOUT 0 | 39 | # define LED_DISABLE_TIMEOUT (LED_DISABLE_AFTER_TIMEOUT * 1200UL) |
40 | #endif | ||
41 | |||
42 | #ifndef LED_DISABLE_TIMEOUT | ||
43 | # define LED_DISABLE_TIMEOUT 0 | ||
42 | #endif | 44 | #endif |
43 | 45 | ||
44 | #ifndef LED_DISABLE_WHEN_USB_SUSPENDED | 46 | #ifndef LED_DISABLE_WHEN_USB_SUSPENDED |
45 | # define LED_DISABLE_WHEN_USB_SUSPENDED false | 47 | # define LED_DISABLE_WHEN_USB_SUSPENDED false |
46 | #endif | 48 | #endif |
47 | 49 | ||
48 | #ifndef EECONFIG_LED_MATRIX | 50 | #if !defined(LED_MATRIX_MAXIMUM_BRIGHTNESS) || LED_MATRIX_MAXIMUM_BRIGHTNESS > UINT8_MAX |
49 | # define EECONFIG_LED_MATRIX EECONFIG_RGBLIGHT | 51 | # undef LED_MATRIX_MAXIMUM_BRIGHTNESS |
52 | # define LED_MATRIX_MAXIMUM_BRIGHTNESS UINT8_MAX | ||
53 | #endif | ||
54 | |||
55 | #if !defined(LED_MATRIX_VAL_STEP) | ||
56 | # define LED_MATRIX_VAL_STEP 8 | ||
57 | #endif | ||
58 | |||
59 | #if !defined(LED_MATRIX_SPD_STEP) | ||
60 | # define LED_MATRIX_SPD_STEP 16 | ||
50 | #endif | 61 | #endif |
51 | 62 | ||
52 | #if !defined(LED_MATRIX_MAXIMUM_BRIGHTNESS) || LED_MATRIX_MAXIMUM_BRIGHTNESS > 255 | 63 | #if !defined(LED_MATRIX_STARTUP_MODE) |
53 | # define LED_MATRIX_MAXIMUM_BRIGHTNESS 255 | 64 | # define LED_MATRIX_STARTUP_MODE LED_MATRIX_UNIFORM_BRIGHTNESS |
54 | #endif | 65 | #endif |
55 | 66 | ||
56 | bool g_suspend_state = false; | 67 | #if !defined(LED_MATRIX_STARTUP_VAL) |
68 | # define LED_MATRIX_STARTUP_VAL LED_MATRIX_MAXIMUM_BRIGHTNESS | ||
69 | #endif | ||
70 | |||
71 | #if !defined(LED_MATRIX_STARTUP_SPD) | ||
72 | # define LED_MATRIX_STARTUP_SPD UINT8_MAX / 2 | ||
73 | #endif | ||
74 | |||
75 | // globals | ||
76 | bool g_suspend_state = false; | ||
77 | led_eeconfig_t led_matrix_eeconfig; // TODO: would like to prefix this with g_ for global consistancy, do this in another pr | ||
57 | 78 | ||
58 | // Global tick at 20 Hz | 79 | // Global tick at 20 Hz |
59 | uint32_t g_tick = 0; | 80 | uint32_t g_tick = 0; |
@@ -64,21 +85,21 @@ uint8_t g_key_hit[DRIVER_LED_TOTAL]; | |||
64 | // Ticks since any key was last hit. | 85 | // Ticks since any key was last hit. |
65 | uint32_t g_any_key_hit = 0; | 86 | uint32_t g_any_key_hit = 0; |
66 | 87 | ||
67 | uint32_t eeconfig_read_led_matrix(void) { return eeprom_read_dword(EECONFIG_LED_MATRIX); } | 88 | void eeconfig_read_led_matrix(void) { eeprom_read_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); } |
68 | 89 | ||
69 | void eeconfig_update_led_matrix(uint32_t config_value) { eeprom_update_dword(EECONFIG_LED_MATRIX, config_value); } | 90 | void eeconfig_update_led_matrix(void) { eeprom_update_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); } |
70 | 91 | ||
71 | void eeconfig_update_led_matrix_default(void) { | 92 | void eeconfig_update_led_matrix_default(void) { |
72 | dprintf("eeconfig_update_led_matrix_default\n"); | 93 | dprintf("eeconfig_update_led_matrix_default\n"); |
73 | led_matrix_eeconfig.enable = 1; | 94 | led_matrix_eeconfig.enable = 1; |
74 | led_matrix_eeconfig.mode = LED_MATRIX_UNIFORM_BRIGHTNESS; | 95 | led_matrix_eeconfig.mode = LED_MATRIX_STARTUP_MODE; |
75 | led_matrix_eeconfig.val = 128; | 96 | led_matrix_eeconfig.val = LED_MATRIX_STARTUP_VAL; |
76 | led_matrix_eeconfig.speed = 0; | 97 | led_matrix_eeconfig.speed = LED_MATRIX_STARTUP_SPD; |
77 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 98 | eeconfig_update_led_matrix(); |
78 | } | 99 | } |
79 | 100 | ||
80 | void eeconfig_debug_led_matrix(void) { | 101 | void eeconfig_debug_led_matrix(void) { |
81 | dprintf("led_matrix_eeconfig eeprom\n"); | 102 | dprintf("led_matrix_eeconfig EEPROM\n"); |
82 | dprintf("led_matrix_eeconfig.enable = %d\n", led_matrix_eeconfig.enable); | 103 | dprintf("led_matrix_eeconfig.enable = %d\n", led_matrix_eeconfig.enable); |
83 | dprintf("led_matrix_eeconfig.mode = %d\n", led_matrix_eeconfig.mode); | 104 | dprintf("led_matrix_eeconfig.mode = %d\n", led_matrix_eeconfig.mode); |
84 | dprintf("led_matrix_eeconfig.val = %d\n", led_matrix_eeconfig.val); | 105 | dprintf("led_matrix_eeconfig.val = %d\n", led_matrix_eeconfig.val); |
@@ -88,8 +109,10 @@ void eeconfig_debug_led_matrix(void) { | |||
88 | uint8_t g_last_led_hit[LED_HITS_TO_REMEMBER] = {255}; | 109 | uint8_t g_last_led_hit[LED_HITS_TO_REMEMBER] = {255}; |
89 | uint8_t g_last_led_count = 0; | 110 | uint8_t g_last_led_count = 0; |
90 | 111 | ||
91 | uint8_t map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) { | 112 | __attribute__((weak)) uint8_t led_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i) { return 0; } |
92 | uint8_t led_count = 0; | 113 | |
114 | uint8_t led_matrix_map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) { | ||
115 | uint8_t led_count = led_matrix_map_row_column_to_led_kb(row, column, led_i); | ||
93 | uint8_t led_index = g_led_config.matrix_co[row][column]; | 116 | uint8_t led_index = g_led_config.matrix_co[row][column]; |
94 | if (led_index != NO_LED) { | 117 | if (led_index != NO_LED) { |
95 | led_i[led_count] = led_index; | 118 | led_i[led_count] = led_index; |
@@ -100,14 +123,26 @@ uint8_t map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) { | |||
100 | 123 | ||
101 | void led_matrix_update_pwm_buffers(void) { led_matrix_driver.flush(); } | 124 | void led_matrix_update_pwm_buffers(void) { led_matrix_driver.flush(); } |
102 | 125 | ||
103 | void led_matrix_set_index_value(int index, uint8_t value) { led_matrix_driver.set_value(index, value); } | 126 | void led_matrix_set_value(int index, uint8_t value) { |
127 | #ifdef USE_CIE1931_CURVE | ||
128 | led_matrix_driver.set_value(index, pgm_read_byte(&CIE1931_CURVE[value])); | ||
129 | #else | ||
130 | led_matrix_driver.set_value(index, value); | ||
131 | #endif | ||
132 | } | ||
104 | 133 | ||
105 | void led_matrix_set_index_value_all(uint8_t value) { led_matrix_driver.set_value_all(value); } | 134 | void led_matrix_set_value_all(uint8_t value) { |
135 | #ifdef USE_CIE1931_CURVE | ||
136 | led_matrix_driver.set_value_all(pgm_read_byte(&CIE1931_CURVE[value])); | ||
137 | #else | ||
138 | led_matrix_driver.set_value_all(value); | ||
139 | #endif | ||
140 | } | ||
106 | 141 | ||
107 | bool process_led_matrix(uint16_t keycode, keyrecord_t *record) { | 142 | void process_led_matrix(uint8_t row, uint8_t col, bool pressed) { |
108 | if (record->event.pressed) { | 143 | if (pressed) { |
109 | uint8_t led[8]; | 144 | uint8_t led[8]; |
110 | uint8_t led_count = map_row_column_to_led(record->event.key.row, record->event.key.col, led); | 145 | uint8_t led_count = led_matrix_map_row_column_to_led(row, col, led); |
111 | if (led_count > 0) { | 146 | if (led_count > 0) { |
112 | for (uint8_t i = LED_HITS_TO_REMEMBER; i > 1; i--) { | 147 | for (uint8_t i = LED_HITS_TO_REMEMBER; i > 1; i--) { |
113 | g_last_led_hit[i - 1] = g_last_led_hit[i - 2]; | 148 | g_last_led_hit[i - 1] = g_last_led_hit[i - 2]; |
@@ -120,28 +155,24 @@ bool process_led_matrix(uint16_t keycode, keyrecord_t *record) { | |||
120 | } else { | 155 | } else { |
121 | #ifdef LED_MATRIX_KEYRELEASES | 156 | #ifdef LED_MATRIX_KEYRELEASES |
122 | uint8_t led[8]; | 157 | uint8_t led[8]; |
123 | uint8_t led_count = map_row_column_to_led(record->event.key.row, record->event.key.col, led); | 158 | uint8_t led_count = led_matrix_map_row_column_to_led(row, .col, led); |
124 | for (uint8_t i = 0; i < led_count; i++) g_key_hit[led[i]] = 255; | 159 | for (uint8_t i = 0; i < led_count; i++) g_key_hit[led[i]] = 255; |
125 | 160 | ||
126 | g_any_key_hit = 255; | 161 | g_any_key_hit = 255; |
127 | #endif | 162 | #endif |
128 | } | 163 | } |
129 | return true; | ||
130 | } | 164 | } |
131 | 165 | ||
132 | void led_matrix_set_suspend_state(bool state) { g_suspend_state = state; } | 166 | static void led_matrix_none(void) { led_matrix_set_value_all(0); } |
133 | |||
134 | // All LEDs off | ||
135 | void led_matrix_all_off(void) { led_matrix_set_index_value_all(0); } | ||
136 | 167 | ||
137 | // Uniform brightness | 168 | // Uniform brightness |
138 | void led_matrix_uniform_brightness(void) { led_matrix_set_index_value_all(LED_MATRIX_MAXIMUM_BRIGHTNESS / BACKLIGHT_LEVELS * led_matrix_eeconfig.val); } | 169 | void led_matrix_uniform_brightness(void) { led_matrix_set_value_all(led_matrix_eeconfig.val); } |
139 | 170 | ||
140 | void led_matrix_custom(void) {} | 171 | void led_matrix_custom(void) {} |
141 | 172 | ||
142 | void led_matrix_task(void) { | 173 | void led_matrix_task(void) { |
143 | if (!led_matrix_eeconfig.enable) { | 174 | if (!led_matrix_eeconfig.enable) { |
144 | led_matrix_all_off(); | 175 | led_matrix_none(); |
145 | led_matrix_indicators(); | 176 | led_matrix_indicators(); |
146 | return; | 177 | return; |
147 | } | 178 | } |
@@ -161,13 +192,23 @@ void led_matrix_task(void) { | |||
161 | 192 | ||
162 | // Ideally we would also stop sending zeros to the LED driver PWM buffers | 193 | // Ideally we would also stop sending zeros to the LED driver PWM buffers |
163 | // while suspended and just do a software shutdown. This is a cheap hack for now. | 194 | // while suspended and just do a software shutdown. This is a cheap hack for now. |
164 | bool suspend_backlight = ((g_suspend_state && LED_DISABLE_WHEN_USB_SUSPENDED) || (LED_DISABLE_AFTER_TIMEOUT > 0 && g_any_key_hit > LED_DISABLE_AFTER_TIMEOUT * 60 * 20)); | 195 | bool suspend_backlight = |
165 | uint8_t effect = suspend_backlight ? 0 : led_matrix_eeconfig.mode; | 196 | #if LED_DISABLE_WHEN_USB_SUSPENDED == true |
197 | g_suspend_state || | ||
198 | #endif // LED_DISABLE_WHEN_USB_SUSPENDED == true | ||
199 | #if LED_DISABLE_TIMEOUT > 0 | ||
200 | (g_any_key_hit > (uint32_t)LED_DISABLE_TIMEOUT) || | ||
201 | #endif // LED_DISABLE_TIMEOUT > 0 | ||
202 | false; | ||
203 | |||
204 | uint8_t effect = suspend_backlight || !led_matrix_eeconfig.enable ? 0 : led_matrix_eeconfig.mode; | ||
166 | 205 | ||
167 | // this gets ticked at 20 Hz. | 206 | // this gets ticked at 20 Hz. |
168 | // each effect can opt to do calculations | 207 | // each effect can opt to do calculations |
169 | // and/or request PWM buffer updates. | 208 | // and/or request PWM buffer updates. |
170 | switch (effect) { | 209 | switch (effect) { |
210 | case LED_MATRIX_NONE: | ||
211 | led_matrix_none(); | ||
171 | case LED_MATRIX_UNIFORM_BRIGHTNESS: | 212 | case LED_MATRIX_UNIFORM_BRIGHTNESS: |
172 | led_matrix_uniform_brightness(); | 213 | led_matrix_uniform_brightness(); |
173 | break; | 214 | break; |
@@ -176,7 +217,7 @@ void led_matrix_task(void) { | |||
176 | break; | 217 | break; |
177 | } | 218 | } |
178 | 219 | ||
179 | if (!suspend_backlight) { | 220 | if (effect) { |
180 | led_matrix_indicators(); | 221 | led_matrix_indicators(); |
181 | } | 222 | } |
182 | 223 | ||
@@ -193,23 +234,6 @@ __attribute__((weak)) void led_matrix_indicators_kb(void) {} | |||
193 | 234 | ||
194 | __attribute__((weak)) void led_matrix_indicators_user(void) {} | 235 | __attribute__((weak)) void led_matrix_indicators_user(void) {} |
195 | 236 | ||
196 | // void led_matrix_set_indicator_index(uint8_t *index, uint8_t row, uint8_t column) | ||
197 | // { | ||
198 | // if (row >= MATRIX_ROWS) | ||
199 | // { | ||
200 | // // Special value, 255=none, 254=all | ||
201 | // *index = row; | ||
202 | // } | ||
203 | // else | ||
204 | // { | ||
205 | // // This needs updated to something like | ||
206 | // // uint8_t led[8]; | ||
207 | // // uint8_t led_count = map_row_column_to_led(row, column, led); | ||
208 | // // for(uint8_t i = 0; i < led_count; i++) | ||
209 | // map_row_column_to_led(row, column, index); | ||
210 | // } | ||
211 | // } | ||
212 | |||
213 | void led_matrix_init(void) { | 237 | void led_matrix_init(void) { |
214 | led_matrix_driver.init(); | 238 | led_matrix_driver.init(); |
215 | 239 | ||
@@ -227,122 +251,123 @@ void led_matrix_init(void) { | |||
227 | eeconfig_update_led_matrix_default(); | 251 | eeconfig_update_led_matrix_default(); |
228 | } | 252 | } |
229 | 253 | ||
230 | led_matrix_eeconfig.raw = eeconfig_read_led_matrix(); | 254 | eeconfig_read_led_matrix(); |
231 | |||
232 | if (!led_matrix_eeconfig.mode) { | 255 | if (!led_matrix_eeconfig.mode) { |
233 | dprintf("led_matrix_init_drivers led_matrix_eeconfig.mode = 0. Write default values to EEPROM.\n"); | 256 | dprintf("led_matrix_init_drivers led_matrix_eeconfig.mode = 0. Write default values to EEPROM.\n"); |
234 | eeconfig_update_led_matrix_default(); | 257 | eeconfig_update_led_matrix_default(); |
235 | led_matrix_eeconfig.raw = eeconfig_read_led_matrix(); | ||
236 | } | 258 | } |
237 | |||
238 | eeconfig_debug_led_matrix(); // display current eeprom values | 259 | eeconfig_debug_led_matrix(); // display current eeprom values |
239 | } | 260 | } |
240 | 261 | ||
241 | // Deals with the messy details of incrementing an integer | 262 | void led_matrix_set_suspend_state(bool state) { |
242 | static uint8_t increment(uint8_t value, uint8_t step, uint8_t min, uint8_t max) { | 263 | if (LED_DISABLE_WHEN_USB_SUSPENDED && state) { |
243 | int16_t new_value = value; | 264 | led_matrix_set_value_all(0); // turn off all LEDs when suspending |
244 | new_value += step; | 265 | } |
245 | return MIN(MAX(new_value, min), max); | 266 | g_suspend_state = state; |
246 | } | 267 | } |
247 | 268 | ||
248 | static uint8_t decrement(uint8_t value, uint8_t step, uint8_t min, uint8_t max) { | 269 | bool led_matrix_get_suspend_state(void) { return g_suspend_state; } |
249 | int16_t new_value = value; | ||
250 | new_value -= step; | ||
251 | return MIN(MAX(new_value, min), max); | ||
252 | } | ||
253 | 270 | ||
254 | // void *backlight_get_custom_key_value_eeprom_address(uint8_t led) { | 271 | void led_matrix_toggle_eeprom_helper(bool write_to_eeprom) { |
255 | // // 3 bytes per value | ||
256 | // return EECONFIG_LED_MATRIX + (led * 3); | ||
257 | // } | ||
258 | |||
259 | // void backlight_get_key_value(uint8_t led, uint8_t *value) { | ||
260 | // void *address = backlight_get_custom_key_value_eeprom_address(led); | ||
261 | // value = eeprom_read_byte(address); | ||
262 | // } | ||
263 | |||
264 | // void backlight_set_key_value(uint8_t row, uint8_t column, uint8_t value) { | ||
265 | // uint8_t led[8]; | ||
266 | // uint8_t led_count = map_row_column_to_led(row, column, led); | ||
267 | // for(uint8_t i = 0; i < led_count; i++) { | ||
268 | // if (led[i] < DRIVER_LED_TOTAL) { | ||
269 | // void *address = backlight_get_custom_key_value_eeprom_address(led[i]); | ||
270 | // eeprom_update_byte(address, value); | ||
271 | // } | ||
272 | // } | ||
273 | // } | ||
274 | |||
275 | uint32_t led_matrix_get_tick(void) { return g_tick; } | ||
276 | |||
277 | void led_matrix_toggle(void) { | ||
278 | led_matrix_eeconfig.enable ^= 1; | 272 | led_matrix_eeconfig.enable ^= 1; |
279 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 273 | if (write_to_eeprom) { |
274 | eeconfig_update_led_matrix(); | ||
275 | } | ||
276 | dprintf("led matrix toggle [%s]: led_matrix_eeconfig.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.enable); | ||
280 | } | 277 | } |
278 | void led_matrix_toggle_noeeprom(void) { led_matrix_toggle_eeprom_helper(false); } | ||
279 | void led_matrix_toggle(void) { led_matrix_toggle_eeprom_helper(true); } | ||
281 | 280 | ||
282 | void led_matrix_enable(void) { | 281 | void led_matrix_enable(void) { |
283 | led_matrix_eeconfig.enable = 1; | 282 | led_matrix_enable_noeeprom(); |
284 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 283 | eeconfig_update_led_matrix(); |
285 | } | 284 | } |
286 | 285 | ||
287 | void led_matrix_enable_noeeprom(void) { led_matrix_eeconfig.enable = 1; } | 286 | void led_matrix_enable_noeeprom(void) { led_matrix_eeconfig.enable = 1; } |
288 | 287 | ||
289 | void led_matrix_disable(void) { | 288 | void led_matrix_disable(void) { |
290 | led_matrix_eeconfig.enable = 0; | 289 | led_matrix_disable_noeeprom(); |
291 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 290 | eeconfig_update_led_matrix(); |
292 | } | 291 | } |
293 | 292 | ||
294 | void led_matrix_disable_noeeprom(void) { led_matrix_eeconfig.enable = 0; } | 293 | void led_matrix_disable_noeeprom(void) { led_matrix_eeconfig.enable = 0; } |
295 | 294 | ||
296 | void led_matrix_step(void) { | 295 | uint8_t led_matrix_is_enabled(void) { return led_matrix_eeconfig.enable; } |
297 | led_matrix_eeconfig.mode++; | ||
298 | if (led_matrix_eeconfig.mode >= LED_MATRIX_EFFECT_MAX) { | ||
299 | led_matrix_eeconfig.mode = 1; | ||
300 | } | ||
301 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | ||
302 | } | ||
303 | 296 | ||
304 | void led_matrix_step_reverse(void) { | 297 | void led_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) { |
305 | led_matrix_eeconfig.mode--; | 298 | if (!led_matrix_eeconfig.enable) { |
306 | if (led_matrix_eeconfig.mode < 1) { | 299 | return; |
300 | } | ||
301 | if (mode < 1) { | ||
302 | led_matrix_eeconfig.mode = 1; | ||
303 | } else if (mode >= LED_MATRIX_EFFECT_MAX) { | ||
307 | led_matrix_eeconfig.mode = LED_MATRIX_EFFECT_MAX - 1; | 304 | led_matrix_eeconfig.mode = LED_MATRIX_EFFECT_MAX - 1; |
305 | } else { | ||
306 | led_matrix_eeconfig.mode = mode; | ||
308 | } | 307 | } |
309 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 308 | if (write_to_eeprom) { |
310 | } | 309 | eeconfig_update_led_matrix(); |
311 | 310 | } | |
312 | void led_matrix_increase_val(void) { | 311 | dprintf("led matrix mode [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.mode); |
313 | led_matrix_eeconfig.val = increment(led_matrix_eeconfig.val, 8, 0, LED_MATRIX_MAXIMUM_BRIGHTNESS); | ||
314 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | ||
315 | } | 312 | } |
313 | void led_matrix_mode_noeeprom(uint8_t mode) { led_matrix_mode_eeprom_helper(mode, false); } | ||
314 | void led_matrix_mode(uint8_t mode) { led_matrix_mode_eeprom_helper(mode, true); } | ||
316 | 315 | ||
317 | void led_matrix_decrease_val(void) { | 316 | uint8_t led_matrix_get_mode(void) { return led_matrix_eeconfig.mode; } |
318 | led_matrix_eeconfig.val = decrement(led_matrix_eeconfig.val, 8, 0, LED_MATRIX_MAXIMUM_BRIGHTNESS); | ||
319 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | ||
320 | } | ||
321 | 317 | ||
322 | void led_matrix_increase_speed(void) { | 318 | void led_matrix_step_helper(bool write_to_eeprom) { |
323 | led_matrix_eeconfig.speed = increment(led_matrix_eeconfig.speed, 1, 0, 3); | 319 | uint8_t mode = led_matrix_eeconfig.mode + 1; |
324 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); // EECONFIG needs to be increased to support this | 320 | led_matrix_mode_eeprom_helper((mode < LED_MATRIX_EFFECT_MAX) ? mode : 1, write_to_eeprom); |
325 | } | 321 | } |
322 | void led_matrix_step_noeeprom(void) { led_matrix_step_helper(false); } | ||
323 | void led_matrix_step(void) { led_matrix_step_helper(true); } | ||
326 | 324 | ||
327 | void led_matrix_decrease_speed(void) { | 325 | void led_matrix_step_reverse_helper(bool write_to_eeprom) { |
328 | led_matrix_eeconfig.speed = decrement(led_matrix_eeconfig.speed, 1, 0, 3); | 326 | uint8_t mode = led_matrix_eeconfig.mode - 1; |
329 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); // EECONFIG needs to be increased to support this | 327 | led_matrix_mode_eeprom_helper((mode < 1) ? LED_MATRIX_EFFECT_MAX - 1 : mode, write_to_eeprom); |
330 | } | 328 | } |
329 | void led_matrix_step_reverse_noeeprom(void) { led_matrix_step_reverse_helper(false); } | ||
330 | void led_matrix_step_reverse(void) { led_matrix_step_reverse_helper(true); } | ||
331 | 331 | ||
332 | void led_matrix_mode(uint8_t mode, bool eeprom_write) { | 332 | void led_matrix_set_val_eeprom_helper(uint8_t val, bool write_to_eeprom) { |
333 | led_matrix_eeconfig.mode = mode; | 333 | if (!led_matrix_eeconfig.enable) { |
334 | if (eeprom_write) { | 334 | return; |
335 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 335 | } |
336 | led_matrix_eeconfig.val = (val > LED_MATRIX_MAXIMUM_BRIGHTNESS) ? LED_MATRIX_MAXIMUM_BRIGHTNESS : val; | ||
337 | if (write_to_eeprom) { | ||
338 | eeconfig_update_led_matrix(); | ||
336 | } | 339 | } |
340 | dprintf("led matrix set val [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.val); | ||
337 | } | 341 | } |
342 | void led_matrix_set_val_noeeprom(uint8_t val) { led_matrix_set_val_eeprom_helper(val, false); } | ||
343 | void led_matrix_set_val(uint8_t val) { led_matrix_set_val_eeprom_helper(val, true); } | ||
338 | 344 | ||
339 | uint8_t led_matrix_get_mode(void) { return led_matrix_eeconfig.mode; } | 345 | uint8_t led_matrix_get_val(void) { return led_matrix_eeconfig.val; } |
346 | |||
347 | void led_matrix_increase_val_helper(bool write_to_eeprom) { led_matrix_set_val_eeprom_helper(qadd8(led_matrix_eeconfig.val, LED_MATRIX_VAL_STEP), write_to_eeprom); } | ||
348 | void led_matrix_increase_val_noeeprom(void) { led_matrix_increase_val_helper(false); } | ||
349 | void led_matrix_increase_val(void) { led_matrix_increase_val_helper(true); } | ||
340 | 350 | ||
341 | void led_matrix_set_value_noeeprom(uint8_t val) { led_matrix_eeconfig.val = val; } | 351 | void led_matrix_decrease_val_helper(bool write_to_eeprom) { led_matrix_set_val_eeprom_helper(qsub8(led_matrix_eeconfig.val, LED_MATRIX_VAL_STEP), write_to_eeprom); } |
352 | void led_matrix_decrease_val_noeeprom(void) { led_matrix_decrease_val_helper(false); } | ||
353 | void led_matrix_decrease_val(void) { led_matrix_decrease_val_helper(true); } | ||
342 | 354 | ||
343 | void led_matrix_set_value(uint8_t val) { | 355 | void led_matrix_set_speed_eeprom_helper(uint8_t speed, bool write_to_eeprom) { |
344 | led_matrix_set_value_noeeprom(val); | 356 | led_matrix_eeconfig.speed = speed; |
345 | eeconfig_update_led_matrix(led_matrix_eeconfig.raw); | 357 | if (write_to_eeprom) { |
358 | eeconfig_update_led_matrix(); | ||
359 | } | ||
360 | dprintf("led matrix set speed [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.speed); | ||
346 | } | 361 | } |
362 | void led_matrix_set_speed_noeeprom(uint8_t speed) { led_matrix_set_speed_eeprom_helper(speed, false); } | ||
363 | void led_matrix_set_speed(uint8_t speed) { led_matrix_set_speed_eeprom_helper(speed, true); } | ||
364 | |||
365 | uint8_t led_matrix_get_speed(void) { return led_matrix_eeconfig.speed; } | ||
366 | |||
367 | void led_matrix_increase_speed_helper(bool write_to_eeprom) { led_matrix_set_speed_eeprom_helper(qadd8(led_matrix_eeconfig.speed, LED_MATRIX_SPD_STEP), write_to_eeprom); } | ||
368 | void led_matrix_increase_speed_noeeprom(void) { led_matrix_increase_speed_helper(false); } | ||
369 | void led_matrix_increase_speed(void) { led_matrix_increase_speed_helper(true); } | ||
347 | 370 | ||
348 | void backlight_set(uint8_t val) { led_matrix_set_value(val); } | 371 | void led_matrix_decrease_speed_helper(bool write_to_eeprom) { led_matrix_set_speed_eeprom_helper(qsub8(led_matrix_eeconfig.speed, LED_MATRIX_SPD_STEP), write_to_eeprom); } |
372 | void led_matrix_decrease_speed_noeeprom(void) { led_matrix_decrease_speed_helper(false); } | ||
373 | void led_matrix_decrease_speed(void) { led_matrix_decrease_speed_helper(true); } | ||