Move LED/RGB Matrix code into their own directories (#13257)
This commit is contained in:
Ryan
GitHub
parent
c03cb4edd7
commit
d61e5c0027
80 changed files with 108 additions and 100 deletions
24
quantum/led_matrix/animations/alpha_mods_anim.h
Normal file
24
quantum/led_matrix/animations/alpha_mods_anim.h
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
#ifndef DISABLE_LED_MATRIX_ALPHAS_MODS
|
||||
LED_MATRIX_EFFECT(ALPHAS_MODS)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
// alphas = val1, mods = val2
|
||||
bool ALPHAS_MODS(effect_params_t* params) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t val1 = led_matrix_eeconfig.val;
|
||||
uint8_t val2 = val1 + led_matrix_eeconfig.speed;
|
||||
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
if (HAS_FLAGS(g_led_config.flags[i], LED_FLAG_MODIFIER)) {
|
||||
led_matrix_set_value(i, val2);
|
||||
} else {
|
||||
led_matrix_set_value(i, val1);
|
||||
}
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_ALPHAS_MODS
|
||||
13
quantum/led_matrix/animations/band_anim.h
Normal file
13
quantum/led_matrix/animations/band_anim.h
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
#ifndef DISABLE_LED_MATRIX_BAND
|
||||
LED_MATRIX_EFFECT(BAND)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t BAND_math(uint8_t val, uint8_t i, uint8_t time) {
|
||||
int16_t v = val - abs(scale8(g_led_config.point[i].x, 228) + 28 - time) * 8;
|
||||
return scale8(v < 0 ? 0 : v, val);
|
||||
}
|
||||
|
||||
bool BAND(effect_params_t* params) { return effect_runner_i(params, &BAND_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_BAND
|
||||
10
quantum/led_matrix/animations/band_pinwheel_anim.h
Normal file
10
quantum/led_matrix/animations/band_pinwheel_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_BAND_PINWHEEL
|
||||
LED_MATRIX_EFFECT(BAND_PINWHEEL)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t BAND_PINWHEEL_math(uint8_t val, int16_t dx, int16_t dy, uint8_t time) { return scale8(val - time - atan2_8(dy, dx) * 3, val); }
|
||||
|
||||
bool BAND_PINWHEEL(effect_params_t* params) { return effect_runner_dx_dy(params, &BAND_PINWHEEL_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_BAND_PINWHEEL
|
||||
10
quantum/led_matrix/animations/band_spiral_anim.h
Normal file
10
quantum/led_matrix/animations/band_spiral_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_BAND_SPIRAL
|
||||
LED_MATRIX_EFFECT(BAND_SPIRAL)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t BAND_SPIRAL_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { return scale8(val + dist - time - atan2_8(dy, dx), val); }
|
||||
|
||||
bool BAND_SPIRAL(effect_params_t* params) { return effect_runner_dx_dy_dist(params, &BAND_SPIRAL_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_BAND_SPIRAL
|
||||
19
quantum/led_matrix/animations/breathing_anim.h
Normal file
19
quantum/led_matrix/animations/breathing_anim.h
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
#ifndef DISABLE_LED_MATRIX_BREATHING
|
||||
LED_MATRIX_EFFECT(BREATHING)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
bool BREATHING(effect_params_t* params) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t val = led_matrix_eeconfig.val;
|
||||
uint16_t time = scale16by8(g_led_timer, led_matrix_eeconfig.speed / 8);
|
||||
val = scale8(abs8(sin8(time) - 128) * 2, val);
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
led_matrix_set_value(i, val);
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_BREATHING
|
||||
10
quantum/led_matrix/animations/cycle_left_right_anim.h
Normal file
10
quantum/led_matrix/animations/cycle_left_right_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_CYCLE_LEFT_RIGHT
|
||||
LED_MATRIX_EFFECT(CYCLE_LEFT_RIGHT)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t CYCLE_LEFT_RIGHT_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(g_led_config.point[i].x - time, val); }
|
||||
|
||||
bool CYCLE_LEFT_RIGHT(effect_params_t* params) { return effect_runner_i(params, &CYCLE_LEFT_RIGHT_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_CYCLE_LEFT_RIGHT
|
||||
10
quantum/led_matrix/animations/cycle_out_in_anim.h
Normal file
10
quantum/led_matrix/animations/cycle_out_in_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_CYCLE_OUT_IN
|
||||
LED_MATRIX_EFFECT(CYCLE_OUT_IN)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t CYCLE_OUT_IN_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { return scale8(3 * dist / 2 + time, val); }
|
||||
|
||||
bool CYCLE_OUT_IN(effect_params_t* params) { return effect_runner_dx_dy_dist(params, &CYCLE_OUT_IN_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_CYCLE_OUT_IN
|
||||
10
quantum/led_matrix/animations/cycle_up_down_anim.h
Normal file
10
quantum/led_matrix/animations/cycle_up_down_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_CYCLE_UP_DOWN
|
||||
LED_MATRIX_EFFECT(CYCLE_UP_DOWN)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t CYCLE_UP_DOWN_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(g_led_config.point[i].y - time, val); }
|
||||
|
||||
bool CYCLE_UP_DOWN(effect_params_t* params) { return effect_runner_i(params, &CYCLE_UP_DOWN_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_CYCLE_UP_DOWN
|
||||
10
quantum/led_matrix/animations/dual_beacon_anim.h
Normal file
10
quantum/led_matrix/animations/dual_beacon_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_DUAL_BEACON
|
||||
LED_MATRIX_EFFECT(DUAL_BEACON)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t DUAL_BEACON_math(uint8_t val, int8_t sin, int8_t cos, uint8_t i, uint8_t time) { return scale8(((g_led_config.point[i].y - k_led_matrix_center.y) * cos + (g_led_config.point[i].x - k_led_matrix_center.x) * sin) / 128, val); }
|
||||
|
||||
bool DUAL_BEACON(effect_params_t* params) { return effect_runner_sin_cos_i(params, &DUAL_BEACON_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_DUAL_BEACON
|
||||
18
quantum/led_matrix/animations/led_matrix_effects.inc
Normal file
18
quantum/led_matrix/animations/led_matrix_effects.inc
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
// Add your new core led matrix effect here, order determines enum order
|
||||
#include "solid_anim.h"
|
||||
#include "alpha_mods_anim.h"
|
||||
#include "breathing_anim.h"
|
||||
#include "band_anim.h"
|
||||
#include "band_pinwheel_anim.h"
|
||||
#include "band_spiral_anim.h"
|
||||
#include "cycle_left_right_anim.h"
|
||||
#include "cycle_up_down_anim.h"
|
||||
#include "cycle_out_in_anim.h"
|
||||
#include "dual_beacon_anim.h"
|
||||
#include "solid_reactive_simple_anim.h"
|
||||
#include "solid_reactive_wide.h"
|
||||
#include "solid_reactive_cross.h"
|
||||
#include "solid_reactive_nexus.h"
|
||||
#include "solid_splash_anim.h"
|
||||
#include "wave_left_right_anim.h"
|
||||
#include "wave_up_down_anim.h"
|
||||
16
quantum/led_matrix/animations/runners/effect_runner_dx_dy.h
Normal file
16
quantum/led_matrix/animations/runners/effect_runner_dx_dy.h
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
#pragma once
|
||||
|
||||
typedef uint8_t (*dx_dy_f)(uint8_t val, int16_t dx, int16_t dy, uint8_t time);
|
||||
|
||||
bool effect_runner_dx_dy(effect_params_t* params, dx_dy_f effect_func) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t time = scale16by8(g_led_timer, led_matrix_eeconfig.speed / 2);
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
int16_t dx = g_led_config.point[i].x - k_led_matrix_center.x;
|
||||
int16_t dy = g_led_config.point[i].y - k_led_matrix_center.y;
|
||||
led_matrix_set_value(i, effect_func(led_matrix_eeconfig.val, dx, dy, time));
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#pragma once
|
||||
|
||||
typedef uint8_t (*dx_dy_dist_f)(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint8_t time);
|
||||
|
||||
bool effect_runner_dx_dy_dist(effect_params_t* params, dx_dy_dist_f effect_func) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t time = scale16by8(g_led_timer, led_matrix_eeconfig.speed / 2);
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
int16_t dx = g_led_config.point[i].x - k_led_matrix_center.x;
|
||||
int16_t dy = g_led_config.point[i].y - k_led_matrix_center.y;
|
||||
uint8_t dist = sqrt16(dx * dx + dy * dy);
|
||||
led_matrix_set_value(i, effect_func(led_matrix_eeconfig.val, dx, dy, dist, time));
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
14
quantum/led_matrix/animations/runners/effect_runner_i.h
Normal file
14
quantum/led_matrix/animations/runners/effect_runner_i.h
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
#pragma once
|
||||
|
||||
typedef uint8_t (*i_f)(uint8_t val, uint8_t i, uint8_t time);
|
||||
|
||||
bool effect_runner_i(effect_params_t* params, i_f effect_func) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t time = scale16by8(g_led_timer, led_matrix_eeconfig.speed / 4);
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
led_matrix_set_value(i, effect_func(led_matrix_eeconfig.val, i, time));
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#pragma once
|
||||
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
typedef uint8_t (*reactive_f)(uint8_t val, uint16_t offset);
|
||||
|
||||
bool effect_runner_reactive(effect_params_t* params, reactive_f effect_func) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint16_t max_tick = 65535 / led_matrix_eeconfig.speed;
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
uint16_t tick = max_tick;
|
||||
// Reverse search to find most recent key hit
|
||||
for (int8_t j = g_last_hit_tracker.count - 1; j >= 0; j--) {
|
||||
if (g_last_hit_tracker.index[j] == i && g_last_hit_tracker.tick[j] < tick) {
|
||||
tick = g_last_hit_tracker.tick[j];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t offset = scale16by8(tick, led_matrix_eeconfig.speed);
|
||||
led_matrix_set_value(i, effect_func(led_matrix_eeconfig.val, offset));
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
#pragma once
|
||||
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
typedef uint8_t (*reactive_splash_f)(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick);
|
||||
|
||||
bool effect_runner_reactive_splash(uint8_t start, effect_params_t* params, reactive_splash_f effect_func) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t count = g_last_hit_tracker.count;
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
uint8_t val = 0;
|
||||
for (uint8_t j = start; j < count; j++) {
|
||||
int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j];
|
||||
int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j];
|
||||
uint8_t dist = sqrt16(dx * dx + dy * dy);
|
||||
uint16_t tick = scale16by8(g_last_hit_tracker.tick[j], led_matrix_eeconfig.speed);
|
||||
val = effect_func(val, dx, dy, dist, tick);
|
||||
}
|
||||
led_matrix_set_value(i, scale8(val, led_matrix_eeconfig.val));
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
#pragma once
|
||||
|
||||
typedef uint8_t (*sin_cos_i_f)(uint8_t val, int8_t sin, int8_t cos, uint8_t i, uint8_t time);
|
||||
|
||||
bool effect_runner_sin_cos_i(effect_params_t* params, sin_cos_i_f effect_func) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint16_t time = scale16by8(g_led_timer, led_matrix_eeconfig.speed / 4);
|
||||
int8_t cos_value = cos8(time) - 128;
|
||||
int8_t sin_value = sin8(time) - 128;
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
led_matrix_set_value(i, effect_func(led_matrix_eeconfig.val, cos_value, sin_value, i, time));
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
#include "effect_runner_dx_dy_dist.h"
|
||||
#include "effect_runner_dx_dy.h"
|
||||
#include "effect_runner_i.h"
|
||||
#include "effect_runner_sin_cos_i.h"
|
||||
#include "effect_runner_reactive.h"
|
||||
#include "effect_runner_reactive_splash.h"
|
||||
15
quantum/led_matrix/animations/solid_anim.h
Normal file
15
quantum/led_matrix/animations/solid_anim.h
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
LED_MATRIX_EFFECT(SOLID)
|
||||
#ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
bool SOLID(effect_params_t* params) {
|
||||
LED_MATRIX_USE_LIMITS(led_min, led_max);
|
||||
|
||||
uint8_t val = led_matrix_eeconfig.val;
|
||||
for (uint8_t i = led_min; i < led_max; i++) {
|
||||
LED_MATRIX_TEST_LED_FLAGS();
|
||||
led_matrix_set_value(i, val);
|
||||
}
|
||||
return led_max < DRIVER_LED_TOTAL;
|
||||
}
|
||||
|
||||
#endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
35
quantum/led_matrix/animations/solid_reactive_cross.h
Normal file
35
quantum/led_matrix/animations/solid_reactive_cross.h
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
# if !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS)
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_CROSS)
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_MULTICROSS)
|
||||
# endif
|
||||
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t SOLID_REACTIVE_CROSS_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) {
|
||||
uint16_t effect = tick + dist;
|
||||
dx = dx < 0 ? dx * -1 : dx;
|
||||
dy = dy < 0 ? dy * -1 : dy;
|
||||
dx = dx * 16 > 255 ? 255 : dx * 16;
|
||||
dy = dy * 16 > 255 ? 255 : dy * 16;
|
||||
effect += dx > dy ? dy : dx;
|
||||
if (effect > 255) effect = 255;
|
||||
return qadd8(val, 255 - effect);
|
||||
}
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS
|
||||
bool SOLID_REACTIVE_CROSS(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_CROSS_math); }
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS
|
||||
bool SOLID_REACTIVE_MULTICROSS(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_CROSS_math); }
|
||||
# endif
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
# endif // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTICROSS)
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
32
quantum/led_matrix/animations/solid_reactive_nexus.h
Normal file
32
quantum/led_matrix/animations/solid_reactive_nexus.h
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
# if !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS)
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_NEXUS)
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_MULTINEXUS)
|
||||
# endif
|
||||
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t SOLID_REACTIVE_NEXUS_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) {
|
||||
uint16_t effect = tick - dist;
|
||||
if (effect > 255) effect = 255;
|
||||
if (dist > 72) effect = 255;
|
||||
if ((dx > 8 || dx < -8) && (dy > 8 || dy < -8)) effect = 255;
|
||||
return qadd8(val, 255 - effect);
|
||||
}
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS
|
||||
bool SOLID_REACTIVE_NEXUS(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_NEXUS_math); }
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS
|
||||
bool SOLID_REACTIVE_MULTINEXUS(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_NEXUS_math); }
|
||||
# endif
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
# endif // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTINEXUS)
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
12
quantum/led_matrix/animations/solid_reactive_simple_anim.h
Normal file
12
quantum/led_matrix/animations/solid_reactive_simple_anim.h
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_SIMPLE
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_SIMPLE)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t SOLID_REACTIVE_SIMPLE_math(uint8_t val, uint16_t offset) { return scale8(255 - offset, val); }
|
||||
|
||||
bool SOLID_REACTIVE_SIMPLE(effect_params_t* params) { return effect_runner_reactive(params, &SOLID_REACTIVE_SIMPLE_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
# endif // DISABLE_LED_MATRIX_SOLID_REACTIVE_SIMPLE
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
30
quantum/led_matrix/animations/solid_reactive_wide.h
Normal file
30
quantum/led_matrix/animations/solid_reactive_wide.h
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
# if !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE)
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_WIDE)
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE
|
||||
LED_MATRIX_EFFECT(SOLID_REACTIVE_MULTIWIDE)
|
||||
# endif
|
||||
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t SOLID_REACTIVE_WIDE_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) {
|
||||
uint16_t effect = tick + dist * 5;
|
||||
if (effect > 255) effect = 255;
|
||||
return qadd8(val, 255 - effect);
|
||||
}
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE
|
||||
bool SOLID_REACTIVE_WIDE(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_WIDE_math); }
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE
|
||||
bool SOLID_REACTIVE_MULTIWIDE(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_WIDE_math); }
|
||||
# endif
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
# endif // !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_LED_MATRIX_SOLID_REACTIVE_MULTIWIDE)
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
30
quantum/led_matrix/animations/solid_splash_anim.h
Normal file
30
quantum/led_matrix/animations/solid_splash_anim.h
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
# if !defined(DISABLE_LED_MATRIX_SOLID_SPLASH) || !defined(DISABLE_LED_MATRIX_SOLID_MULTISPLASH)
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_SPLASH
|
||||
LED_MATRIX_EFFECT(SOLID_SPLASH)
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_MULTISPLASH
|
||||
LED_MATRIX_EFFECT(SOLID_MULTISPLASH)
|
||||
# endif
|
||||
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
uint8_t SOLID_SPLASH_math(uint8_t val, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) {
|
||||
uint16_t effect = tick - dist;
|
||||
if (effect > 255) effect = 255;
|
||||
return qadd8(val, 255 - effect);
|
||||
}
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_SPLASH
|
||||
bool SOLID_SPLASH(effect_params_t* params) { return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_SPLASH_math); }
|
||||
# endif
|
||||
|
||||
# ifndef DISABLE_LED_MATRIX_SOLID_MULTISPLASH
|
||||
bool SOLID_MULTISPLASH(effect_params_t* params) { return effect_runner_reactive_splash(0, params, &SOLID_SPLASH_math); }
|
||||
# endif
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
# endif // !defined(DISABLE_LED_MATRIX_SPLASH) && !defined(DISABLE_LED_MATRIX_MULTISPLASH)
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
10
quantum/led_matrix/animations/wave_left_right_anim.h
Normal file
10
quantum/led_matrix/animations/wave_left_right_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_WAVE_LEFT_RIGHT
|
||||
LED_MATRIX_EFFECT(WAVE_LEFT_RIGHT)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t WAVE_LEFT_RIGHT_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(sin8(g_led_config.point[i].x - time), val); }
|
||||
|
||||
bool WAVE_LEFT_RIGHT(effect_params_t* params) { return effect_runner_i(params, &WAVE_LEFT_RIGHT_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_WAVE_LEFT_RIGHT
|
||||
10
quantum/led_matrix/animations/wave_up_down_anim.h
Normal file
10
quantum/led_matrix/animations/wave_up_down_anim.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef DISABLE_LED_MATRIX_WAVE_UP_DOWN
|
||||
LED_MATRIX_EFFECT(WAVE_UP_DOWN)
|
||||
# ifdef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
static uint8_t WAVE_UP_DOWN_math(uint8_t val, uint8_t i, uint8_t time) { return scale8(sin8(g_led_config.point[i].y - time), val); }
|
||||
|
||||
bool WAVE_UP_DOWN(effect_params_t* params) { return effect_runner_i(params, &WAVE_UP_DOWN_math); }
|
||||
|
||||
# endif // LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#endif // DISABLE_LED_MATRIX_WAVE_UP_DOWN
|
||||
577
quantum/led_matrix/led_matrix.c
Normal file
577
quantum/led_matrix/led_matrix.c
Normal file
|
|
@ -0,0 +1,577 @@
|
|||
/* Copyright 2017 Jason Williams
|
||||
* Copyright 2017 Jack Humbert
|
||||
* Copyright 2018 Yiancar
|
||||
* Copyright 2019 Clueboard
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "led_matrix.h"
|
||||
#include "progmem.h"
|
||||
#include "config.h"
|
||||
#include "eeprom.h"
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include "led_tables.h"
|
||||
|
||||
#include <lib/lib8tion/lib8tion.h>
|
||||
|
||||
#ifndef LED_MATRIX_CENTER
|
||||
const led_point_t k_led_matrix_center = {112, 32};
|
||||
#else
|
||||
const led_point_t k_led_matrix_center = LED_MATRIX_CENTER;
|
||||
#endif
|
||||
|
||||
// clang-format off
|
||||
#ifndef LED_MATRIX_IMMEDIATE_EEPROM
|
||||
# define led_eeconfig_update(v) led_update_eeprom |= v
|
||||
#else
|
||||
# define led_eeconfig_update(v) if (v) eeconfig_update_led_matrix()
|
||||
#endif
|
||||
// clang-format on
|
||||
|
||||
// Generic effect runners
|
||||
#include "led_matrix_runners.inc"
|
||||
|
||||
// ------------------------------------------
|
||||
// -----Begin led effect includes macros-----
|
||||
#define LED_MATRIX_EFFECT(name)
|
||||
#define LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
|
||||
#include "led_matrix_effects.inc"
|
||||
#ifdef LED_MATRIX_CUSTOM_KB
|
||||
# include "led_matrix_kb.inc"
|
||||
#endif
|
||||
#ifdef LED_MATRIX_CUSTOM_USER
|
||||
# include "led_matrix_user.inc"
|
||||
#endif
|
||||
|
||||
#undef LED_MATRIX_CUSTOM_EFFECT_IMPLS
|
||||
#undef LED_MATRIX_EFFECT
|
||||
// -----End led effect includes macros-------
|
||||
// ------------------------------------------
|
||||
|
||||
#if defined(LED_DISABLE_AFTER_TIMEOUT) && !defined(LED_DISABLE_TIMEOUT)
|
||||
# define LED_DISABLE_TIMEOUT (LED_DISABLE_AFTER_TIMEOUT * 1200UL)
|
||||
#endif
|
||||
|
||||
#ifndef LED_DISABLE_TIMEOUT
|
||||
# define LED_DISABLE_TIMEOUT 0
|
||||
#endif
|
||||
|
||||
#if !defined(LED_MATRIX_MAXIMUM_BRIGHTNESS) || LED_MATRIX_MAXIMUM_BRIGHTNESS > UINT8_MAX
|
||||
# undef LED_MATRIX_MAXIMUM_BRIGHTNESS
|
||||
# define LED_MATRIX_MAXIMUM_BRIGHTNESS UINT8_MAX
|
||||
#endif
|
||||
|
||||
#if !defined(LED_MATRIX_VAL_STEP)
|
||||
# define LED_MATRIX_VAL_STEP 8
|
||||
#endif
|
||||
|
||||
#if !defined(LED_MATRIX_SPD_STEP)
|
||||
# define LED_MATRIX_SPD_STEP 16
|
||||
#endif
|
||||
|
||||
#if !defined(LED_MATRIX_STARTUP_MODE)
|
||||
# define LED_MATRIX_STARTUP_MODE LED_MATRIX_SOLID
|
||||
#endif
|
||||
|
||||
#if !defined(LED_MATRIX_STARTUP_VAL)
|
||||
# define LED_MATRIX_STARTUP_VAL LED_MATRIX_MAXIMUM_BRIGHTNESS
|
||||
#endif
|
||||
|
||||
#if !defined(LED_MATRIX_STARTUP_SPD)
|
||||
# define LED_MATRIX_STARTUP_SPD UINT8_MAX / 2
|
||||
#endif
|
||||
|
||||
// globals
|
||||
led_eeconfig_t led_matrix_eeconfig; // TODO: would like to prefix this with g_ for global consistancy, do this in another pr
|
||||
uint32_t g_led_timer;
|
||||
#ifdef LED_MATRIX_FRAMEBUFFER_EFFECTS
|
||||
uint8_t g_led_frame_buffer[MATRIX_ROWS][MATRIX_COLS] = {{0}};
|
||||
#endif // LED_MATRIX_FRAMEBUFFER_EFFECTS
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
last_hit_t g_last_hit_tracker;
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
// internals
|
||||
static bool suspend_state = false;
|
||||
static bool led_update_eeprom = false;
|
||||
static uint8_t led_last_enable = UINT8_MAX;
|
||||
static uint8_t led_last_effect = UINT8_MAX;
|
||||
static effect_params_t led_effect_params = {0, LED_FLAG_ALL, false};
|
||||
static led_task_states led_task_state = SYNCING;
|
||||
#if LED_DISABLE_TIMEOUT > 0
|
||||
static uint32_t led_anykey_timer;
|
||||
#endif // LED_DISABLE_TIMEOUT > 0
|
||||
|
||||
// double buffers
|
||||
static uint32_t led_timer_buffer;
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
static last_hit_t last_hit_buffer;
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
// split led matrix
|
||||
#if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_SPLIT)
|
||||
const uint8_t k_led_matrix_split[2] = LED_MATRIX_SPLIT;
|
||||
#endif
|
||||
|
||||
void eeconfig_read_led_matrix(void) { eeprom_read_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); }
|
||||
|
||||
void eeconfig_update_led_matrix(void) { eeprom_update_block(&led_matrix_eeconfig, EECONFIG_LED_MATRIX, sizeof(led_matrix_eeconfig)); }
|
||||
|
||||
void eeconfig_update_led_matrix_default(void) {
|
||||
dprintf("eeconfig_update_led_matrix_default\n");
|
||||
led_matrix_eeconfig.enable = 1;
|
||||
led_matrix_eeconfig.mode = LED_MATRIX_STARTUP_MODE;
|
||||
led_matrix_eeconfig.val = LED_MATRIX_STARTUP_VAL;
|
||||
led_matrix_eeconfig.speed = LED_MATRIX_STARTUP_SPD;
|
||||
led_matrix_eeconfig.flags = LED_FLAG_ALL;
|
||||
eeconfig_update_led_matrix();
|
||||
}
|
||||
|
||||
void eeconfig_debug_led_matrix(void) {
|
||||
dprintf("led_matrix_eeconfig EEPROM\n");
|
||||
dprintf("led_matrix_eeconfig.enable = %d\n", led_matrix_eeconfig.enable);
|
||||
dprintf("led_matrix_eeconfig.mode = %d\n", led_matrix_eeconfig.mode);
|
||||
dprintf("led_matrix_eeconfig.val = %d\n", led_matrix_eeconfig.val);
|
||||
dprintf("led_matrix_eeconfig.speed = %d\n", led_matrix_eeconfig.speed);
|
||||
dprintf("led_matrix_eeconfig.flags = %d\n", led_matrix_eeconfig.flags);
|
||||
}
|
||||
|
||||
__attribute__((weak)) uint8_t led_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i) { return 0; }
|
||||
|
||||
uint8_t led_matrix_map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) {
|
||||
uint8_t led_count = led_matrix_map_row_column_to_led_kb(row, column, led_i);
|
||||
uint8_t led_index = g_led_config.matrix_co[row][column];
|
||||
if (led_index != NO_LED) {
|
||||
led_i[led_count] = led_index;
|
||||
led_count++;
|
||||
}
|
||||
return led_count;
|
||||
}
|
||||
|
||||
void led_matrix_update_pwm_buffers(void) { led_matrix_driver.flush(); }
|
||||
|
||||
void led_matrix_set_value(int index, uint8_t value) {
|
||||
#if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_SPLIT)
|
||||
if (!is_keyboard_left() && index >= k_led_matrix_split[0])
|
||||
# ifdef USE_CIE1931_CURVE
|
||||
led_matrix_driver.set_value(index - k_led_matrix_split[0], pgm_read_byte(&CIE1931_CURVE[value]));
|
||||
# else
|
||||
led_matrix_driver.set_value(index - k_led_matrix_split[0], value);
|
||||
# endif
|
||||
else if (is_keyboard_left() && index < k_led_matrix_split[0])
|
||||
#endif
|
||||
#ifdef USE_CIE1931_CURVE
|
||||
led_matrix_driver.set_value(index, pgm_read_byte(&CIE1931_CURVE[value]));
|
||||
#else
|
||||
led_matrix_driver.set_value(index, value);
|
||||
#endif
|
||||
}
|
||||
|
||||
void led_matrix_set_value_all(uint8_t value) {
|
||||
#if defined(LED_MATRIX_ENABLE) && defined(LED_MATRIX_SPLIT)
|
||||
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) led_matrix_set_value(i, value);
|
||||
#else
|
||||
# ifdef USE_CIE1931_CURVE
|
||||
led_matrix_driver.set_value_all(pgm_read_byte(&CIE1931_CURVE[value]));
|
||||
# else
|
||||
led_matrix_driver.set_value_all(value);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void process_led_matrix(uint8_t row, uint8_t col, bool pressed) {
|
||||
#ifndef LED_MATRIX_SPLIT
|
||||
if (!is_keyboard_master()) return;
|
||||
#endif
|
||||
#if LED_DISABLE_TIMEOUT > 0
|
||||
led_anykey_timer = 0;
|
||||
#endif // LED_DISABLE_TIMEOUT > 0
|
||||
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
uint8_t led[LED_HITS_TO_REMEMBER];
|
||||
uint8_t led_count = 0;
|
||||
|
||||
# if defined(LED_MATRIX_KEYRELEASES)
|
||||
if (!pressed)
|
||||
# elif defined(LED_MATRIX_KEYPRESSES)
|
||||
if (pressed)
|
||||
# endif // defined(LED_MATRIX_KEYRELEASES)
|
||||
{
|
||||
led_count = led_matrix_map_row_column_to_led(row, col, led);
|
||||
}
|
||||
|
||||
if (last_hit_buffer.count + led_count > LED_HITS_TO_REMEMBER) {
|
||||
memcpy(&last_hit_buffer.x[0], &last_hit_buffer.x[led_count], LED_HITS_TO_REMEMBER - led_count);
|
||||
memcpy(&last_hit_buffer.y[0], &last_hit_buffer.y[led_count], LED_HITS_TO_REMEMBER - led_count);
|
||||
memcpy(&last_hit_buffer.tick[0], &last_hit_buffer.tick[led_count], (LED_HITS_TO_REMEMBER - led_count) * 2); // 16 bit
|
||||
memcpy(&last_hit_buffer.index[0], &last_hit_buffer.index[led_count], LED_HITS_TO_REMEMBER - led_count);
|
||||
last_hit_buffer.count--;
|
||||
}
|
||||
|
||||
for (uint8_t i = 0; i < led_count; i++) {
|
||||
uint8_t index = last_hit_buffer.count;
|
||||
last_hit_buffer.x[index] = g_led_config.point[led[i]].x;
|
||||
last_hit_buffer.y[index] = g_led_config.point[led[i]].y;
|
||||
last_hit_buffer.index[index] = led[i];
|
||||
last_hit_buffer.tick[index] = 0;
|
||||
last_hit_buffer.count++;
|
||||
}
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
#if defined(LED_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_LED_MATRIX_TYPING_HEATMAP)
|
||||
if (led_matrix_eeconfig.mode == LED_MATRIX_TYPING_HEATMAP) {
|
||||
process_led_matrix_typing_heatmap(row, col);
|
||||
}
|
||||
#endif // defined(LED_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_LED_MATRIX_TYPING_HEATMAP)
|
||||
}
|
||||
|
||||
static bool led_matrix_none(effect_params_t *params) {
|
||||
if (!params->init) {
|
||||
return false;
|
||||
}
|
||||
|
||||
led_matrix_set_value_all(0);
|
||||
return false;
|
||||
}
|
||||
|
||||
static void led_task_timers(void) {
|
||||
#if defined(LED_MATRIX_KEYREACTIVE_ENABLED) || LED_DISABLE_TIMEOUT > 0
|
||||
uint32_t deltaTime = sync_timer_elapsed32(led_timer_buffer);
|
||||
#endif // defined(LED_MATRIX_KEYREACTIVE_ENABLED) || LED_DISABLE_TIMEOUT > 0
|
||||
led_timer_buffer = sync_timer_read32();
|
||||
|
||||
// Update double buffer timers
|
||||
#if LED_DISABLE_TIMEOUT > 0
|
||||
if (led_anykey_timer < UINT32_MAX) {
|
||||
if (UINT32_MAX - deltaTime < led_anykey_timer) {
|
||||
led_anykey_timer = UINT32_MAX;
|
||||
} else {
|
||||
led_anykey_timer += deltaTime;
|
||||
}
|
||||
}
|
||||
#endif // LED_DISABLE_TIMEOUT > 0
|
||||
|
||||
// Update double buffer last hit timers
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
uint8_t count = last_hit_buffer.count;
|
||||
for (uint8_t i = 0; i < count; ++i) {
|
||||
if (UINT16_MAX - deltaTime < last_hit_buffer.tick[i]) {
|
||||
last_hit_buffer.count--;
|
||||
continue;
|
||||
}
|
||||
last_hit_buffer.tick[i] += deltaTime;
|
||||
}
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
}
|
||||
|
||||
static void led_task_sync(void) {
|
||||
// next task
|
||||
if (led_update_eeprom) eeconfig_update_led_matrix();
|
||||
led_update_eeprom = false;
|
||||
if (sync_timer_elapsed32(g_led_timer) >= LED_MATRIX_LED_FLUSH_LIMIT) led_task_state = STARTING;
|
||||
}
|
||||
|
||||
static void led_task_start(void) {
|
||||
// reset iter
|
||||
led_effect_params.iter = 0;
|
||||
|
||||
// update double buffers
|
||||
g_led_timer = led_timer_buffer;
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
g_last_hit_tracker = last_hit_buffer;
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
// next task
|
||||
led_task_state = RENDERING;
|
||||
}
|
||||
|
||||
static void led_task_render(uint8_t effect) {
|
||||
bool rendering = false;
|
||||
led_effect_params.init = (effect != led_last_effect) || (led_matrix_eeconfig.enable != led_last_enable);
|
||||
if (led_effect_params.flags != led_matrix_eeconfig.flags) {
|
||||
led_effect_params.flags = led_matrix_eeconfig.flags;
|
||||
led_matrix_set_value_all(0);
|
||||
}
|
||||
|
||||
// each effect can opt to do calculations
|
||||
// and/or request PWM buffer updates.
|
||||
switch (effect) {
|
||||
case LED_MATRIX_NONE:
|
||||
rendering = led_matrix_none(&led_effect_params);
|
||||
break;
|
||||
|
||||
// ---------------------------------------------
|
||||
// -----Begin led effect switch case macros-----
|
||||
#define LED_MATRIX_EFFECT(name, ...) \
|
||||
case LED_MATRIX_##name: \
|
||||
rendering = name(&led_effect_params); \
|
||||
break;
|
||||
#include "led_matrix_effects.inc"
|
||||
#undef LED_MATRIX_EFFECT
|
||||
|
||||
#if defined(LED_MATRIX_CUSTOM_KB) || defined(LED_MATRIX_CUSTOM_USER)
|
||||
# define LED_MATRIX_EFFECT(name, ...) \
|
||||
case LED_MATRIX_CUSTOM_##name: \
|
||||
rendering = name(&led_effect_params); \
|
||||
break;
|
||||
# ifdef LED_MATRIX_CUSTOM_KB
|
||||
# include "led_matrix_kb.inc"
|
||||
# endif
|
||||
# ifdef LED_MATRIX_CUSTOM_USER
|
||||
# include "led_matrix_user.inc"
|
||||
# endif
|
||||
# undef LED_MATRIX_EFFECT
|
||||
#endif
|
||||
// -----End led effect switch case macros-------
|
||||
// ---------------------------------------------
|
||||
}
|
||||
|
||||
led_effect_params.iter++;
|
||||
|
||||
// next task
|
||||
if (!rendering) {
|
||||
led_task_state = FLUSHING;
|
||||
if (!led_effect_params.init && effect == LED_MATRIX_NONE) {
|
||||
// We only need to flush once if we are LED_MATRIX_NONE
|
||||
led_task_state = SYNCING;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void led_task_flush(uint8_t effect) {
|
||||
// update last trackers after the first full render so we can init over several frames
|
||||
led_last_effect = effect;
|
||||
led_last_enable = led_matrix_eeconfig.enable;
|
||||
|
||||
// update pwm buffers
|
||||
led_matrix_update_pwm_buffers();
|
||||
|
||||
// next task
|
||||
led_task_state = SYNCING;
|
||||
}
|
||||
|
||||
void led_matrix_task(void) {
|
||||
led_task_timers();
|
||||
|
||||
// Ideally we would also stop sending zeros to the LED driver PWM buffers
|
||||
// while suspended and just do a software shutdown. This is a cheap hack for now.
|
||||
bool suspend_backlight = suspend_state ||
|
||||
#if LED_DISABLE_TIMEOUT > 0
|
||||
(led_anykey_timer > (uint32_t)LED_DISABLE_TIMEOUT) ||
|
||||
#endif // LED_DISABLE_TIMEOUT > 0
|
||||
false;
|
||||
|
||||
uint8_t effect = suspend_backlight || !led_matrix_eeconfig.enable ? 0 : led_matrix_eeconfig.mode;
|
||||
|
||||
switch (led_task_state) {
|
||||
case STARTING:
|
||||
led_task_start();
|
||||
break;
|
||||
case RENDERING:
|
||||
led_task_render(effect);
|
||||
if (effect) {
|
||||
led_matrix_indicators();
|
||||
led_matrix_indicators_advanced(&led_effect_params);
|
||||
}
|
||||
break;
|
||||
case FLUSHING:
|
||||
led_task_flush(effect);
|
||||
break;
|
||||
case SYNCING:
|
||||
led_task_sync();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void led_matrix_indicators(void) {
|
||||
led_matrix_indicators_kb();
|
||||
led_matrix_indicators_user();
|
||||
}
|
||||
|
||||
__attribute__((weak)) void led_matrix_indicators_kb(void) {}
|
||||
|
||||
__attribute__((weak)) void led_matrix_indicators_user(void) {}
|
||||
|
||||
void led_matrix_indicators_advanced(effect_params_t *params) {
|
||||
/* special handling is needed for "params->iter", since it's already been incremented.
|
||||
* Could move the invocations to led_task_render, but then it's missing a few checks
|
||||
* and not sure which would be better. Otherwise, this should be called from
|
||||
* led_task_render, right before the iter++ line.
|
||||
*/
|
||||
#if defined(LED_MATRIX_LED_PROCESS_LIMIT) && LED_MATRIX_LED_PROCESS_LIMIT > 0 && LED_MATRIX_LED_PROCESS_LIMIT < DRIVER_LED_TOTAL
|
||||
uint8_t min = LED_MATRIX_LED_PROCESS_LIMIT * (params->iter - 1);
|
||||
uint8_t max = min + LED_MATRIX_LED_PROCESS_LIMIT;
|
||||
if (max > DRIVER_LED_TOTAL) max = DRIVER_LED_TOTAL;
|
||||
#else
|
||||
uint8_t min = 0;
|
||||
uint8_t max = DRIVER_LED_TOTAL;
|
||||
#endif
|
||||
led_matrix_indicators_advanced_kb(min, max);
|
||||
led_matrix_indicators_advanced_user(min, max);
|
||||
}
|
||||
|
||||
__attribute__((weak)) void led_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {}
|
||||
|
||||
__attribute__((weak)) void led_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {}
|
||||
|
||||
void led_matrix_init(void) {
|
||||
led_matrix_driver.init();
|
||||
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
g_last_hit_tracker.count = 0;
|
||||
for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
|
||||
g_last_hit_tracker.tick[i] = UINT16_MAX;
|
||||
}
|
||||
|
||||
last_hit_buffer.count = 0;
|
||||
for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
|
||||
last_hit_buffer.tick[i] = UINT16_MAX;
|
||||
}
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
if (!eeconfig_is_enabled()) {
|
||||
dprintf("led_matrix_init_drivers eeconfig is not enabled.\n");
|
||||
eeconfig_init();
|
||||
eeconfig_update_led_matrix_default();
|
||||
}
|
||||
|
||||
eeconfig_read_led_matrix();
|
||||
if (!led_matrix_eeconfig.mode) {
|
||||
dprintf("led_matrix_init_drivers led_matrix_eeconfig.mode = 0. Write default values to EEPROM.\n");
|
||||
eeconfig_update_led_matrix_default();
|
||||
}
|
||||
eeconfig_debug_led_matrix(); // display current eeprom values
|
||||
}
|
||||
|
||||
void led_matrix_set_suspend_state(bool state) {
|
||||
#ifdef LED_DISABLE_WHEN_USB_SUSPENDED
|
||||
if (state) {
|
||||
led_matrix_set_value_all(0); // turn off all LEDs when suspending
|
||||
}
|
||||
suspend_state = state;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool led_matrix_get_suspend_state(void) { return suspend_state; }
|
||||
|
||||
void led_matrix_toggle_eeprom_helper(bool write_to_eeprom) {
|
||||
led_matrix_eeconfig.enable ^= 1;
|
||||
led_task_state = STARTING;
|
||||
led_eeconfig_update(write_to_eeprom);
|
||||
dprintf("led matrix toggle [%s]: led_matrix_eeconfig.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.enable);
|
||||
}
|
||||
void led_matrix_toggle_noeeprom(void) { led_matrix_toggle_eeprom_helper(false); }
|
||||
void led_matrix_toggle(void) { led_matrix_toggle_eeprom_helper(true); }
|
||||
|
||||
void led_matrix_enable(void) {
|
||||
led_matrix_enable_noeeprom();
|
||||
led_eeconfig_update(true);
|
||||
}
|
||||
|
||||
void led_matrix_enable_noeeprom(void) {
|
||||
if (!led_matrix_eeconfig.enable) led_task_state = STARTING;
|
||||
led_matrix_eeconfig.enable = 1;
|
||||
}
|
||||
|
||||
void led_matrix_disable(void) {
|
||||
led_matrix_disable_noeeprom();
|
||||
led_eeconfig_update(true);
|
||||
}
|
||||
|
||||
void led_matrix_disable_noeeprom(void) {
|
||||
if (led_matrix_eeconfig.enable) led_task_state = STARTING;
|
||||
led_matrix_eeconfig.enable = 0;
|
||||
}
|
||||
|
||||
uint8_t led_matrix_is_enabled(void) { return led_matrix_eeconfig.enable; }
|
||||
|
||||
void led_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
|
||||
if (!led_matrix_eeconfig.enable) {
|
||||
return;
|
||||
}
|
||||
if (mode < 1) {
|
||||
led_matrix_eeconfig.mode = 1;
|
||||
} else if (mode >= LED_MATRIX_EFFECT_MAX) {
|
||||
led_matrix_eeconfig.mode = LED_MATRIX_EFFECT_MAX - 1;
|
||||
} else {
|
||||
led_matrix_eeconfig.mode = mode;
|
||||
}
|
||||
led_task_state = STARTING;
|
||||
led_eeconfig_update(write_to_eeprom);
|
||||
dprintf("led matrix mode [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.mode);
|
||||
}
|
||||
void led_matrix_mode_noeeprom(uint8_t mode) { led_matrix_mode_eeprom_helper(mode, false); }
|
||||
void led_matrix_mode(uint8_t mode) { led_matrix_mode_eeprom_helper(mode, true); }
|
||||
|
||||
uint8_t led_matrix_get_mode(void) { return led_matrix_eeconfig.mode; }
|
||||
|
||||
void led_matrix_step_helper(bool write_to_eeprom) {
|
||||
uint8_t mode = led_matrix_eeconfig.mode + 1;
|
||||
led_matrix_mode_eeprom_helper((mode < LED_MATRIX_EFFECT_MAX) ? mode : 1, write_to_eeprom);
|
||||
}
|
||||
void led_matrix_step_noeeprom(void) { led_matrix_step_helper(false); }
|
||||
void led_matrix_step(void) { led_matrix_step_helper(true); }
|
||||
|
||||
void led_matrix_step_reverse_helper(bool write_to_eeprom) {
|
||||
uint8_t mode = led_matrix_eeconfig.mode - 1;
|
||||
led_matrix_mode_eeprom_helper((mode < 1) ? LED_MATRIX_EFFECT_MAX - 1 : mode, write_to_eeprom);
|
||||
}
|
||||
void led_matrix_step_reverse_noeeprom(void) { led_matrix_step_reverse_helper(false); }
|
||||
void led_matrix_step_reverse(void) { led_matrix_step_reverse_helper(true); }
|
||||
|
||||
void led_matrix_set_val_eeprom_helper(uint8_t val, bool write_to_eeprom) {
|
||||
if (!led_matrix_eeconfig.enable) {
|
||||
return;
|
||||
}
|
||||
led_matrix_eeconfig.val = (val > LED_MATRIX_MAXIMUM_BRIGHTNESS) ? LED_MATRIX_MAXIMUM_BRIGHTNESS : val;
|
||||
led_eeconfig_update(write_to_eeprom);
|
||||
dprintf("led matrix set val [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.val);
|
||||
}
|
||||
void led_matrix_set_val_noeeprom(uint8_t val) { led_matrix_set_val_eeprom_helper(val, false); }
|
||||
void led_matrix_set_val(uint8_t val) { led_matrix_set_val_eeprom_helper(val, true); }
|
||||
|
||||
uint8_t led_matrix_get_val(void) { return led_matrix_eeconfig.val; }
|
||||
|
||||
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); }
|
||||
void led_matrix_increase_val_noeeprom(void) { led_matrix_increase_val_helper(false); }
|
||||
void led_matrix_increase_val(void) { led_matrix_increase_val_helper(true); }
|
||||
|
||||
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); }
|
||||
void led_matrix_decrease_val_noeeprom(void) { led_matrix_decrease_val_helper(false); }
|
||||
void led_matrix_decrease_val(void) { led_matrix_decrease_val_helper(true); }
|
||||
|
||||
void led_matrix_set_speed_eeprom_helper(uint8_t speed, bool write_to_eeprom) {
|
||||
led_matrix_eeconfig.speed = speed;
|
||||
led_eeconfig_update(write_to_eeprom);
|
||||
dprintf("led matrix set speed [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.speed);
|
||||
}
|
||||
void led_matrix_set_speed_noeeprom(uint8_t speed) { led_matrix_set_speed_eeprom_helper(speed, false); }
|
||||
void led_matrix_set_speed(uint8_t speed) { led_matrix_set_speed_eeprom_helper(speed, true); }
|
||||
|
||||
uint8_t led_matrix_get_speed(void) { return led_matrix_eeconfig.speed; }
|
||||
|
||||
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); }
|
||||
void led_matrix_increase_speed_noeeprom(void) { led_matrix_increase_speed_helper(false); }
|
||||
void led_matrix_increase_speed(void) { led_matrix_increase_speed_helper(true); }
|
||||
|
||||
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); }
|
||||
void led_matrix_decrease_speed_noeeprom(void) { led_matrix_decrease_speed_helper(false); }
|
||||
void led_matrix_decrease_speed(void) { led_matrix_decrease_speed_helper(true); }
|
||||
|
||||
led_flags_t led_matrix_get_flags(void) { return led_matrix_eeconfig.flags; }
|
||||
|
||||
void led_matrix_set_flags(led_flags_t flags) { led_matrix_eeconfig.flags = flags; }
|
||||
160
quantum/led_matrix/led_matrix.h
Normal file
160
quantum/led_matrix/led_matrix.h
Normal file
|
|
@ -0,0 +1,160 @@
|
|||
/* Copyright 2017 Jason Williams
|
||||
* Copyright 2017 Jack Humbert
|
||||
* Copyright 2018 Yiancar
|
||||
* Copyright 2019 Clueboard
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "led_matrix_types.h"
|
||||
#include "quantum.h"
|
||||
|
||||
#ifdef IS31FL3731
|
||||
# include "is31fl3731-simple.h"
|
||||
#endif
|
||||
|
||||
#ifndef LED_MATRIX_LED_FLUSH_LIMIT
|
||||
# define LED_MATRIX_LED_FLUSH_LIMIT 16
|
||||
#endif
|
||||
|
||||
#ifndef LED_MATRIX_LED_PROCESS_LIMIT
|
||||
# define LED_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5
|
||||
#endif
|
||||
|
||||
#if defined(LED_MATRIX_LED_PROCESS_LIMIT) && LED_MATRIX_LED_PROCESS_LIMIT > 0 && LED_MATRIX_LED_PROCESS_LIMIT < DRIVER_LED_TOTAL
|
||||
# define LED_MATRIX_USE_LIMITS(min, max) \
|
||||
uint8_t min = LED_MATRIX_LED_PROCESS_LIMIT * params->iter; \
|
||||
uint8_t max = min + LED_MATRIX_LED_PROCESS_LIMIT; \
|
||||
if (max > DRIVER_LED_TOTAL) max = DRIVER_LED_TOTAL;
|
||||
#else
|
||||
# define LED_MATRIX_USE_LIMITS(min, max) \
|
||||
uint8_t min = 0; \
|
||||
uint8_t max = DRIVER_LED_TOTAL;
|
||||
#endif
|
||||
|
||||
#define LED_MATRIX_TEST_LED_FLAGS() \
|
||||
if (!HAS_ANY_FLAGS(g_led_config.flags[i], params->flags)) continue
|
||||
|
||||
enum led_matrix_effects {
|
||||
LED_MATRIX_NONE = 0,
|
||||
|
||||
// --------------------------------------
|
||||
// -----Begin led effect enum macros-----
|
||||
#define LED_MATRIX_EFFECT(name, ...) LED_MATRIX_##name,
|
||||
#include "led_matrix_effects.inc"
|
||||
#undef LED_MATRIX_EFFECT
|
||||
|
||||
#if defined(LED_MATRIX_CUSTOM_KB) || defined(LED_MATRIX_CUSTOM_USER)
|
||||
# define LED_MATRIX_EFFECT(name, ...) LED_MATRIX_CUSTOM_##name,
|
||||
# ifdef LED_MATRIX_CUSTOM_KB
|
||||
# include "led_matrix_kb.inc"
|
||||
# endif
|
||||
# ifdef LED_MATRIX_CUSTOM_USER
|
||||
# include "led_matrix_user.inc"
|
||||
# endif
|
||||
# undef LED_MATRIX_EFFECT
|
||||
#endif
|
||||
// --------------------------------------
|
||||
// -----End led effect enum macros-------
|
||||
|
||||
LED_MATRIX_EFFECT_MAX
|
||||
};
|
||||
|
||||
void eeconfig_update_led_matrix_default(void);
|
||||
void eeconfig_update_led_matrix(void);
|
||||
void eeconfig_debug_led_matrix(void);
|
||||
|
||||
uint8_t led_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i);
|
||||
uint8_t led_matrix_map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i);
|
||||
|
||||
void led_matrix_set_value(int index, uint8_t value);
|
||||
void led_matrix_set_value_all(uint8_t value);
|
||||
|
||||
void process_led_matrix(uint8_t row, uint8_t col, bool pressed);
|
||||
|
||||
void led_matrix_task(void);
|
||||
|
||||
// This runs after another backlight effect and replaces
|
||||
// values already set
|
||||
void led_matrix_indicators(void);
|
||||
void led_matrix_indicators_kb(void);
|
||||
void led_matrix_indicators_user(void);
|
||||
|
||||
void led_matrix_indicators_advanced(effect_params_t *params);
|
||||
void led_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max);
|
||||
void led_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max);
|
||||
|
||||
void led_matrix_init(void);
|
||||
|
||||
void led_matrix_set_suspend_state(bool state);
|
||||
bool led_matrix_get_suspend_state(void);
|
||||
void led_matrix_toggle(void);
|
||||
void led_matrix_toggle_noeeprom(void);
|
||||
void led_matrix_enable(void);
|
||||
void led_matrix_enable_noeeprom(void);
|
||||
void led_matrix_disable(void);
|
||||
void led_matrix_disable_noeeprom(void);
|
||||
uint8_t led_matrix_is_enabled(void);
|
||||
void led_matrix_mode(uint8_t mode);
|
||||
void led_matrix_mode_noeeprom(uint8_t mode);
|
||||
uint8_t led_matrix_get_mode(void);
|
||||
void led_matrix_step(void);
|
||||
void led_matrix_step_noeeprom(void);
|
||||
void led_matrix_step_reverse(void);
|
||||
void led_matrix_step_reverse_noeeprom(void);
|
||||
void led_matrix_set_val(uint8_t val);
|
||||
void led_matrix_set_val_noeeprom(uint8_t val);
|
||||
uint8_t led_matrix_get_val(void);
|
||||
void led_matrix_increase_val(void);
|
||||
void led_matrix_increase_val_noeeprom(void);
|
||||
void led_matrix_decrease_val(void);
|
||||
void led_matrix_decrease_val_noeeprom(void);
|
||||
void led_matrix_set_speed(uint8_t speed);
|
||||
void led_matrix_set_speed_noeeprom(uint8_t speed);
|
||||
uint8_t led_matrix_get_speed(void);
|
||||
void led_matrix_increase_speed(void);
|
||||
void led_matrix_increase_speed_noeeprom(void);
|
||||
void led_matrix_decrease_speed(void);
|
||||
void led_matrix_decrease_speed_noeeprom(void);
|
||||
led_flags_t led_matrix_get_flags(void);
|
||||
void led_matrix_set_flags(led_flags_t flags);
|
||||
|
||||
typedef struct {
|
||||
/* Perform any initialisation required for the other driver functions to work. */
|
||||
void (*init)(void);
|
||||
|
||||
/* Set the brightness of a single LED in the buffer. */
|
||||
void (*set_value)(int index, uint8_t value);
|
||||
/* Set the brightness of all LEDS on the keyboard in the buffer. */
|
||||
void (*set_value_all)(uint8_t value);
|
||||
/* Flush any buffered changes to the hardware. */
|
||||
void (*flush)(void);
|
||||
} led_matrix_driver_t;
|
||||
|
||||
extern const led_matrix_driver_t led_matrix_driver;
|
||||
|
||||
extern led_eeconfig_t led_matrix_eeconfig;
|
||||
|
||||
extern uint32_t g_led_timer;
|
||||
extern led_config_t g_led_config;
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
extern last_hit_t g_last_hit_tracker;
|
||||
#endif
|
||||
#ifdef LED_MATRIX_FRAMEBUFFER_EFFECTS
|
||||
extern uint8_t g_led_frame_buffer[MATRIX_ROWS][MATRIX_COLS];
|
||||
#endif
|
||||
153
quantum/led_matrix/led_matrix_drivers.c
Normal file
153
quantum/led_matrix/led_matrix_drivers.c
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
/* Copyright 2018 James Laird-Wah
|
||||
* Copyright 2019 Clueboard
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "led_matrix.h"
|
||||
|
||||
/* Each driver needs to define a struct:
|
||||
*
|
||||
* const led_matrix_driver_t led_matrix_driver;
|
||||
*
|
||||
* All members must be provided. Keyboard custom drivers must define this
|
||||
* in their own files.
|
||||
*/
|
||||
|
||||
#if defined(IS31FL3731) || defined(IS31FL3733)
|
||||
|
||||
# include "i2c_master.h"
|
||||
|
||||
static void init(void) {
|
||||
i2c_init();
|
||||
# ifdef IS31FL3731
|
||||
# ifdef LED_DRIVER_ADDR_1
|
||||
IS31FL3731_init(LED_DRIVER_ADDR_1);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_2
|
||||
IS31FL3731_init(LED_DRIVER_ADDR_2);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_3
|
||||
IS31FL3731_init(LED_DRIVER_ADDR_3);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_4
|
||||
IS31FL3731_init(LED_DRIVER_ADDR_4);
|
||||
# endif
|
||||
# else
|
||||
# ifdef LED_DRIVER_ADDR_1
|
||||
# ifndef LED_DRIVER_SYNC_1
|
||||
# define LED_DRIVER_SYNC_1 0
|
||||
# endif
|
||||
IS31FL3733_init(LED_DRIVER_ADDR_1, LED_DRIVER_SYNC_1);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_2
|
||||
# ifndef LED_DRIVER_SYNC_2
|
||||
# define LED_DRIVER_SYNC_2 0
|
||||
# endif
|
||||
IS31FL3733_init(LED_DRIVER_ADDR_2, LED_DRIVER_SYNC_2);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_3
|
||||
# ifndef LED_DRIVER_SYNC_3
|
||||
# define LED_DRIVER_SYNC_3 0
|
||||
# endif
|
||||
IS31FL3733_init(LED_DRIVER_ADDR_3, LED_DRIVER_SYNC_3);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_4
|
||||
# ifndef LED_DRIVER_SYNC_4
|
||||
# define LED_DRIVER_SYNC_4 0
|
||||
# endif
|
||||
IS31FL3733_init(LED_DRIVER_ADDR_4, LED_DRIVER_SYNC_4);
|
||||
# endif
|
||||
# endif
|
||||
|
||||
for (int index = 0; index < DRIVER_LED_TOTAL; index++) {
|
||||
# ifdef IS31FL3731
|
||||
IS31FL3731_set_led_control_register(index, true);
|
||||
# else
|
||||
IS31FL3733_set_led_control_register(index, true);
|
||||
# endif
|
||||
}
|
||||
// This actually updates the LED drivers
|
||||
# ifdef IS31FL3731
|
||||
# ifdef LED_DRIVER_ADDR_1
|
||||
IS31FL3731_update_led_control_registers(LED_DRIVER_ADDR_1, 0);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_2
|
||||
IS31FL3731_update_led_control_registers(LED_DRIVER_ADDR_2, 1);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_3
|
||||
IS31FL3731_update_led_control_registers(LED_DRIVER_ADDR_3, 2);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_4
|
||||
IS31FL3731_update_led_control_registers(LED_DRIVER_ADDR_4, 3);
|
||||
# endif
|
||||
# else
|
||||
# ifdef LED_DRIVER_ADDR_1
|
||||
IS31FL3733_update_led_control_registers(LED_DRIVER_ADDR_1, 0);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_2
|
||||
IS31FL3733_update_led_control_registers(LED_DRIVER_ADDR_2, 1);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_3
|
||||
IS31FL3733_update_led_control_registers(LED_DRIVER_ADDR_3, 2);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_4
|
||||
IS31FL3733_update_led_control_registers(LED_DRIVER_ADDR_4, 3);
|
||||
# endif
|
||||
# endif
|
||||
}
|
||||
|
||||
static void flush(void) {
|
||||
# ifdef IS31FL3731
|
||||
# ifdef LED_DRIVER_ADDR_1
|
||||
IS31FL3731_update_pwm_buffers(LED_DRIVER_ADDR_1, 0);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_2
|
||||
IS31FL3731_update_pwm_buffers(LED_DRIVER_ADDR_2, 1);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_3
|
||||
IS31FL3731_update_pwm_buffers(LED_DRIVER_ADDR_3, 2);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_4
|
||||
IS31FL3731_update_pwm_buffers(LED_DRIVER_ADDR_4, 3);
|
||||
# endif
|
||||
# else
|
||||
# ifdef LED_DRIVER_ADDR_1
|
||||
IS31FL3733_update_pwm_buffers(LED_DRIVER_ADDR_1, 0);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_2
|
||||
IS31FL3733_update_pwm_buffers(LED_DRIVER_ADDR_2, 1);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_3
|
||||
IS31FL3733_update_pwm_buffers(LED_DRIVER_ADDR_3, 2);
|
||||
# endif
|
||||
# ifdef LED_DRIVER_ADDR_4
|
||||
IS31FL3733_update_pwm_buffers(LED_DRIVER_ADDR_4, 3);
|
||||
# endif
|
||||
# endif
|
||||
}
|
||||
|
||||
const led_matrix_driver_t led_matrix_driver = {
|
||||
.init = init,
|
||||
.flush = flush,
|
||||
# ifdef IS31FL3731
|
||||
.set_value = IS31FL3731_set_value,
|
||||
.set_value_all = IS31FL3731_set_value_all,
|
||||
# else
|
||||
.set_value = IS31FL3733_set_value,
|
||||
.set_value_all = IS31FL3733_set_value_all,
|
||||
# endif
|
||||
};
|
||||
|
||||
#endif
|
||||
97
quantum/led_matrix/led_matrix_types.h
Normal file
97
quantum/led_matrix/led_matrix_types.h
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
/* Copyright 2021
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#if defined(__GNUC__)
|
||||
# define PACKED __attribute__((__packed__))
|
||||
#else
|
||||
# define PACKED
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma pack(push, 1)
|
||||
#endif
|
||||
|
||||
#if defined(LED_MATRIX_KEYPRESSES) || defined(LED_MATRIX_KEYRELEASES)
|
||||
# define LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
#endif
|
||||
|
||||
// Last led hit
|
||||
#ifndef LED_HITS_TO_REMEMBER
|
||||
# define LED_HITS_TO_REMEMBER 8
|
||||
#endif // LED_HITS_TO_REMEMBER
|
||||
|
||||
#ifdef LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
typedef struct PACKED {
|
||||
uint8_t count;
|
||||
uint8_t x[LED_HITS_TO_REMEMBER];
|
||||
uint8_t y[LED_HITS_TO_REMEMBER];
|
||||
uint8_t index[LED_HITS_TO_REMEMBER];
|
||||
uint16_t tick[LED_HITS_TO_REMEMBER];
|
||||
} last_hit_t;
|
||||
#endif // LED_MATRIX_KEYREACTIVE_ENABLED
|
||||
|
||||
typedef enum led_task_states { STARTING, RENDERING, FLUSHING, SYNCING } led_task_states;
|
||||
|
||||
typedef uint8_t led_flags_t;
|
||||
|
||||
typedef struct PACKED {
|
||||
uint8_t iter;
|
||||
led_flags_t flags;
|
||||
bool init;
|
||||
} effect_params_t;
|
||||
|
||||
typedef struct PACKED {
|
||||
uint8_t x;
|
||||
uint8_t y;
|
||||
} led_point_t;
|
||||
|
||||
#define HAS_FLAGS(bits, flags) ((bits & flags) == flags)
|
||||
#define HAS_ANY_FLAGS(bits, flags) ((bits & flags) != 0x00)
|
||||
|
||||
#define LED_FLAG_ALL 0xFF
|
||||
#define LED_FLAG_NONE 0x00
|
||||
#define LED_FLAG_MODIFIER 0x01
|
||||
#define LED_FLAG_KEYLIGHT 0x04
|
||||
#define LED_FLAG_INDICATOR 0x08
|
||||
|
||||
#define NO_LED 255
|
||||
|
||||
typedef struct PACKED {
|
||||
uint8_t matrix_co[MATRIX_ROWS][MATRIX_COLS];
|
||||
led_point_t point[DRIVER_LED_TOTAL];
|
||||
uint8_t flags[DRIVER_LED_TOTAL];
|
||||
} led_config_t;
|
||||
|
||||
typedef union {
|
||||
uint32_t raw;
|
||||
struct PACKED {
|
||||
uint8_t enable : 2;
|
||||
uint8_t mode : 6;
|
||||
uint16_t reserved;
|
||||
uint8_t val;
|
||||
uint8_t speed; // EECONFIG needs to be increased to support this
|
||||
led_flags_t flags;
|
||||
};
|
||||
} led_eeconfig_t;
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma pack(pop)
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue