darkkirb/qmk_firmware
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[Keymap] Update andrebrait keymap for GMMK Pro (#21668)

Browse source
This commit is contained in:
Andre Brait 2023-08-14 20:26:22 +02:00 committed by GitHub
parent 815cecfbff
commit 280a96b563
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 133 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/config.h
View file

@ -17,13 +17,14 @@
#pragma once #pragma once
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
#define RGB_MATRIX_TIMEOUT 1200000 // 20 minutes (20 * 60 * 1000ms) # define RGB_MATRIX_TIMEOUT 1200000 // 20 minutes (20 * 60 * 1000ms)
#define RGB_DISABLE_WHEN_USB_SUSPENDED # define RGB_DISABLE_WHEN_USB_SUSPENDED
#endif #endif
// Setting DEBOUNCE to 8 to be a little conservative due to issues with Glorious' proprietary hot-swap sockets // A debounce of 8 represents a minimum key press time of just under 1 refresh at 120Hz
// Slightly higher than the default because we are using sym_eager_pk
#ifdef DEBOUNCE #ifdef DEBOUNCE
#undef DEBOUNCE # undef DEBOUNCE
#endif #endif
#define DEBOUNCE 8 #define DEBOUNCE 8

278
keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/keymap.c
View file

@ -17,26 +17,21 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
enum layers { enum layers { WIN_BASE = 0, WIN_FN, MAC_BASE, MAC_FN };
WIN_BASE = 0,
WIN_FN,
MAC_BASE,
MAC_FN
};
enum custom_keycodes { enum custom_keycodes {
CMDQ_TOG = QK_KB_2 // TECH DEBT: Starts at QK_KB_2 to maintain ordering with VIA definitions. See #19884. Revert to QK_KB_0 when VIA catches up with QMK. CMDQ_TOG = QK_KB_2 // TECH DEBT: Starts at QK_KB_2 to maintain ordering with VIA definitions. See #19884. Revert to QK_KB_0 when VIA catches up with QMK.
}; };
#define KC_TASK LWIN(KC_TAB) // Open Task Manager #define KC_TASK LWIN(KC_TAB) // Open Task Manager
#define KC_FLXP LWIN(KC_E) // Open File Explorer #define KC_FLXP LWIN(KC_E) // Open File Explorer
#define DF_WINB DF(WIN_BASE) // Switch to WIN_BASE layer #define DF_WINB DF(WIN_BASE) // Switch to WIN_BASE layer
#define MO_WINF MO(WIN_FN) // Toggle to WIN_FN layer #define MO_WINF MO(WIN_FN) // Toggle to WIN_FN layer
#define DF_MACB DF(MAC_BASE) // Switch to MAX_BASE layer #define DF_MACB DF(MAC_BASE) // Switch to MAX_BASE layer
#define MO_MACF MO(MAC_FN) // Toggle to MAC_FN layer #define MO_MACF MO(MAC_FN) // Toggle to MAC_FN layer
// clang-format off // clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// The GMMK Pro default layout is: // The GMMK Pro default layout is:
// //
@ -103,111 +98,99 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
#ifdef ENCODER_MAP_ENABLE #ifdef ENCODER_MAP_ENABLE
const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][2] = { const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][2] = {
[WIN_BASE] = { ENCODER_CCW_CW(KC_VOLD, KC_VOLU) }, [WIN_BASE] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[WIN_FN] = { ENCODER_CCW_CW(XXXXXXX, XXXXXXX) }, [WIN_FN] = {ENCODER_CCW_CW(XXXXXXX, XXXXXXX)},
[MAC_BASE] = { ENCODER_CCW_CW(KC_VOLD, KC_VOLU) }, [MAC_BASE] = {ENCODER_CCW_CW(KC_VOLD, KC_VOLU)},
[MAC_FN] = { ENCODER_CCW_CW(XXXXXXX, XXXXXXX) }, [MAC_FN] = {ENCODER_CCW_CW(XXXXXXX, XXXXXXX)},
}; };
#endif #endif
/* To record user preferences */ /* To record user preferences */
typedef union { typedef union {
uint32_t raw; // set to 32-bit of size uint32_t raw; // set to 32-bit of size
struct { struct {
bool rgb_enabled :1; // Artificial RGB ON/OFF flag (1 bit) bool rgb_enabled : 1; // Artificial RGB ON/OFF flag (1 bit)
bool cmd_q_delay_enabled :1; // Toggle CMD+Q delay (1 bit) bool cmd_q_delay_enabled : 1; // Toggle CMD+Q delay (1 bit)
}; };
} user_config_t; } user_config_t;
user_config_t user_config; user_config_t user_config;
/* Delayed keypresses variables and functions */ /* Delayed keypresses variables and functions */
static uint16_t delayed_press_delay = 0; static fast_timer_t delayed_press_delay = 0;
static uint16_t delayed_press_keycode = KC_NO; static uint16_t delayed_press_keycode = KC_NO;
static uint16_t delayed_press_start_time = 0; static fast_timer_t delayed_press_start_time = 0;
static uint16_t delayed_press_sent_keycode = KC_NO; static uint16_t delayed_press_sent_keycode = KC_NO;
static void start_delayed_press(const uint16_t delay, const uint16_t keycode); static void start_delayed_press(fast_timer_t delay, uint16_t keycode);
static bool is_any_delayed_press_pending(void); static void mark_delayed_press_sent(void);
static bool is_delayed_press_pending(const uint16_t keycode); static void mark_delayed_release_sent(void);
static bool is_delayed_press_sent(const uint16_t keycode); static void cancel_delayed_press(void);
static void mark_delayed_press_sent(void);
static void mark_delayed_release_sent(void); #define IS_ANY_DELAYED_PRESS_PENDING() (delayed_press_start_time > 0 && delayed_press_keycode != KC_NO)
static void cancel_delayed_press(void); #define IS_DELAYED_PRESS_PENDING(keycode) (delayed_press_start_time > 0 && delayed_press_keycode == (keycode))
#define IS_DELAYED_PRESS_SENT(keycode) (delayed_press_sent_keycode != KC_NO && delayed_press_sent_keycode == (keycode))
/* CMD+Q delay */ /* CMD+Q delay */
#ifndef CMD_Q_DELAY #ifndef CMD_Q_DELAY
#define CMD_Q_DELAY 1000 # define CMD_Q_DELAY 1000
#endif #endif
#if CMD_Q_DELAY <= 0 || CMD_Q_DELAY >= UINT16_MAX / 2 #if CMD_Q_DELAY <= 0 || CMD_Q_DELAY >= UINT16_MAX / 2
#error "CMD_Q_DELAY must be a positive integer smaller than UINT16_MAX / 2" # error "CMD_Q_DELAY must be a positive integer smaller than UINT16_MAX / 2"
#endif #endif
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
#define CAPS_LOCK_COLOR RGB_RED # define CAPS_LOCK_COLOR RGB_RED
#define WIN_BASE_COLOR RGB_BLUE # define WIN_BASE_COLOR RGB_BLUE
#define WIN_FN_COLOR RGB_BLUE # define WIN_FN_COLOR RGB_BLUE
#define MAC_BASE_COLOR RGB_WHITE # define MAC_BASE_COLOR RGB_WHITE
#define MAC_FN_COLOR RGB_WHITE # define MAC_FN_COLOR RGB_WHITE
#define UNKNOWN_LAYER_COLOR RGB_PINK # define UNKNOWN_LAYER_COLOR RGB_PINK
/* The maximum effects duration */ /* The maximum effects duration */
#ifndef EFFECTS_DURATION # ifndef EFFECTS_DURATION
#define EFFECTS_DURATION 2000 # define EFFECTS_DURATION 2000
#endif # endif
#if EFFECTS_DURATION <= 0 || EFFECTS_DURATION >= UINT16_MAX / 2 # if EFFECTS_DURATION <= 0 || EFFECTS_DURATION >= UINT16_MAX / 2
#error "EFFECTS_DURATION must be a positive integer smaller than UINT16_MAX / 2" # error "EFFECTS_DURATION must be a positive integer smaller than UINT16_MAX / 2"
#endif # endif
/* The interval for the flashing effect */ /* The interval for the flashing effect */
#ifndef FLASHING_EFFECT_INTERVAL # ifndef FLASHING_EFFECT_INTERVAL
#define FLASHING_EFFECT_INTERVAL 250 # define FLASHING_EFFECT_INTERVAL 250
#endif # endif
#if FLASHING_EFFECT_INTERVAL <= 0 || FLASHING_EFFECT_INTERVAL >= UINT16_MAX / 2 # if FLASHING_EFFECT_INTERVAL <= 0 || FLASHING_EFFECT_INTERVAL >= UINT16_MAX / 2
#error "FLASHING_EFFECT_INTERVAL must be a positive integer smaller than UINT16_MAX / 2" # error "FLASHING_EFFECT_INTERVAL must be a positive integer smaller than UINT16_MAX / 2"
#endif # endif
static void set_rgb_layer_winfn(void); static void set_rgb_layer_winfn(void);
static void set_rgb_layer_macfn(void); static void set_rgb_layer_macfn(void);
/* Effects functions */ /* Effects functions */
static float flashing_effect(const uint16_t delta_time); static float flashing_effect(fast_timer_t delta_time);
static float static_effect(const uint16_t delta_time); static float static_effect(fast_timer_t delta_time);
static float increasing_effect(const uint16_t delta_time); static float increasing_effect(fast_timer_t delta_time);
/* Effect variables and functions */ /* Effect variables and functions */
static uint16_t effect_started_time = 0; static fast_timer_t effect_started_time = 0;
static uint16_t effect_max_duration = EFFECTS_DURATION; static fast_timer_t effect_max_duration = EFFECTS_DURATION;
static uint8_t effect_r = 0x0, effect_g = 0x0, effect_b = 0x0; static uint8_t effect_r = 0x0, effect_g = 0x0, effect_b = 0x0;
static float (*effect_multiplier)(const uint16_t) = static_effect; static float (*effect_multiplier)(fast_timer_t) = static_effect;
static void start_effects( static void start_effects(fast_timer_t max_duration, uint8_t r_color, uint8_t g_color, uint8_t b_color, float (*multiplier)(fast_timer_t));
const uint16_t max_duration,
const uint8_t r_color,
const uint8_t g_color,
const uint8_t b_color,
const float (*multiplier)(const uint16_t));
static void stop_effects(void); static void stop_effects(void);
/* Delayed keypresses variables with RGB variant */ /* Delayed keypresses variables with RGB variant */
static void start_delayed_press_with_effects( static void start_delayed_press_with_effects(fast_timer_t delay, uint16_t keycode, uint8_t r_color, uint8_t g_color, uint8_t b_color);
const uint16_t delay,
const uint16_t keycode,
const uint8_t r_color,
const uint8_t g_color,
const uint8_t b_color);
#endif // RGB_MATRIX_ENABLE #endif // RGB_MATRIX_ENABLE
void eeconfig_init_user(void) { // EEPROM is getting reset! void eeconfig_init_user(void) { // EEPROM is getting reset!
user_config.raw = 0; user_config.raw = 0;
user_config.rgb_enabled = true; // We want this enabled by default user_config.rgb_enabled = true; // We want this enabled by default
user_config.cmd_q_delay_enabled = true; // We want this enabled by default user_config.cmd_q_delay_enabled = true; // We want this enabled by default
eeconfig_update_user(user_config.raw); // Write default value to EEPROM now eeconfig_update_user(user_config.raw); // Write default value to EEPROM now
} }
void keyboard_post_init_user(void) { void keyboard_post_init_user(void) {
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
// Enable the RGB matrix, if not enabled // Enable the RGB matrix, if not enabled
if (!rgb_matrix_is_enabled()) { if (!rgb_matrix_is_enabled()) {
rgb_matrix_enable(); rgb_matrix_enable();
@ -216,15 +199,15 @@ void keyboard_post_init_user(void) {
if (rgb_matrix_get_flags() != LED_FLAG_ALL) { if (rgb_matrix_get_flags() != LED_FLAG_ALL) {
rgb_matrix_set_flags(LED_FLAG_ALL); rgb_matrix_set_flags(LED_FLAG_ALL);
} }
#endif #endif
// Read the user config from EEPROM // Read the user config from EEPROM
user_config.raw = eeconfig_read_user(); user_config.raw = eeconfig_read_user();
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {
if (is_any_delayed_press_pending()) { if (IS_ANY_DELAYED_PRESS_PENDING()) {
if (sync_timer_elapsed(delayed_press_start_time) > delayed_press_delay) { if (timer_elapsed_fast(delayed_press_start_time) > delayed_press_delay) {
register_code(delayed_press_keycode); register_code(delayed_press_keycode);
mark_delayed_press_sent(); mark_delayed_press_sent();
} }
@ -232,20 +215,20 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (is_delayed_press_sent(keycode)) { if (IS_DELAYED_PRESS_SENT(keycode)) {
if (!record->event.pressed) { if (!record->event.pressed) {
/* Send key-up event and clear the keycode and stop processing */ /* Send key-up event and clear the keycode and stop processing */
unregister_code(keycode); unregister_code(keycode);
mark_delayed_release_sent(); mark_delayed_release_sent();
return false; return false;
} }
} else if (is_delayed_press_pending(keycode)) { } else if (IS_DELAYED_PRESS_PENDING(keycode)) {
if (!record->event.pressed) { if (!record->event.pressed) {
/* Cancel the pending press and stop processing */ /* Cancel the pending press and stop processing */
cancel_delayed_press(); cancel_delayed_press();
return false; return false;
} }
} else if (is_any_delayed_press_pending()) { } else if (IS_ANY_DELAYED_PRESS_PENDING()) {
/* Cancel the pending press and resume processing */ /* Cancel the pending press and resume processing */
cancel_delayed_press(); cancel_delayed_press();
} }
@ -258,17 +241,15 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return false; return false;
case CMDQ_TOG: case CMDQ_TOG:
if (record->event.pressed) { if (record->event.pressed) {
#ifdef RGB_MATRIX_ENABLE
if (user_config.cmd_q_delay_enabled) { if (user_config.cmd_q_delay_enabled) {
/* Turning delay OFF */ /* Turning delay OFF */
#ifdef RGB_MATRIX_ENABLE
start_effects(EFFECTS_DURATION, RGB_RED, flashing_effect); start_effects(EFFECTS_DURATION, RGB_RED, flashing_effect);
#endif
} else { } else {
/* Turning delay ON */ /* Turning delay ON */
#ifdef RGB_MATRIX_ENABLE
start_effects(EFFECTS_DURATION, RGB_GREEN, flashing_effect); start_effects(EFFECTS_DURATION, RGB_GREEN, flashing_effect);
#endif
} }
#endif
user_config.cmd_q_delay_enabled = !user_config.cmd_q_delay_enabled; user_config.cmd_q_delay_enabled = !user_config.cmd_q_delay_enabled;
eeconfig_update_user(user_config.raw); eeconfig_update_user(user_config.raw);
} }
@ -276,22 +257,22 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
case KC_Q: case KC_Q:
if (user_config.cmd_q_delay_enabled) { if (user_config.cmd_q_delay_enabled) {
if (layer_state_is(MAC_BASE)) { if (layer_state_is(MAC_BASE)) {
const uint8_t mods = get_mods(); uint8_t mods = get_mods();
if (mods == MOD_BIT(KC_LCMD) || mods == MOD_BIT(KC_RCMD)) { if (mods == MOD_BIT(KC_LCMD) || mods == MOD_BIT(KC_RCMD)) {
if (record->event.pressed) { if (record->event.pressed) {
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
start_delayed_press_with_effects(CMD_Q_DELAY, KC_Q, RGB_ORANGE); start_delayed_press_with_effects(CMD_Q_DELAY, KC_Q, RGB_ORANGE);
#else #else
start_delayed_press(CMD_Q_DELAY, KC_Q); start_delayed_press(CMD_Q_DELAY, KC_Q);
#endif #endif
} }
return false; return false;
} }
} }
} }
break; break;
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
#ifdef NKRO_ENABLE # ifdef NKRO_ENABLE
case NK_TOGG: case NK_TOGG:
if (record->event.pressed) { if (record->event.pressed) {
if (keymap_config.nkro) { if (keymap_config.nkro) {
@ -303,52 +284,31 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
} }
break; break;
#endif // NKRO_ENABLE # endif // NKRO_ENABLE
case RGB_MOD:
case RGB_RMOD:
case RGB_HUI:
case RGB_HUD:
case RGB_SAI:
case RGB_SAD:
case RGB_VAI:
case RGB_VAD:
case RGB_SPI:
case RGB_SPD:
if (!user_config.rgb_enabled) {
/* Ignore changes to RGB settings while only it's supposed to be OFF */
return false; // Skip all further processing of this key
}
break;
case RGB_TOG: case RGB_TOG:
if (record->event.pressed) { if (record->event.pressed) {
user_config.rgb_enabled = !user_config.rgb_enabled; user_config.rgb_enabled = !user_config.rgb_enabled;
eeconfig_update_user(user_config.raw); eeconfig_update_user(user_config.raw);
} }
return false; return false;
#endif // RGB_MATRIX_ENABLE case RGB_MODE_FORWARD ... RGB_MODE_TWINKLE:
if (!user_config.rgb_enabled) {
/* Ignore changes to RGB settings while only it's supposed to be OFF */
return false; // Skip all further processing of this key
}
break;
#endif // RGB_MATRIX_ENABLE
} }
return true; return true;
} }
static void start_delayed_press(const uint16_t delay, const uint16_t keycode) { static void start_delayed_press(fast_timer_t delay, uint16_t keycode) {
delayed_press_delay = delay; delayed_press_delay = delay;
delayed_press_keycode = keycode; delayed_press_keycode = keycode;
delayed_press_start_time = sync_timer_read(); delayed_press_start_time = timer_read_fast();
delayed_press_sent_keycode = KC_NO; delayed_press_sent_keycode = KC_NO;
} }
static bool is_any_delayed_press_pending(void) {
return delayed_press_start_time > 0 && delayed_press_keycode != KC_NO;
}
static bool is_delayed_press_pending(const uint16_t keycode) {
return delayed_press_start_time > 0 && delayed_press_keycode == keycode;
}
static bool is_delayed_press_sent(const uint16_t keycode) {
return delayed_press_sent_keycode != KC_NO && delayed_press_sent_keycode == keycode;
}
static void mark_delayed_press_sent(void) { static void mark_delayed_press_sent(void) {
delayed_press_sent_keycode = delayed_press_keycode; delayed_press_sent_keycode = delayed_press_keycode;
cancel_delayed_press(); cancel_delayed_press();
@ -359,22 +319,17 @@ static void mark_delayed_release_sent(void) {
} }
static void cancel_delayed_press(void) { static void cancel_delayed_press(void) {
delayed_press_delay = 0; delayed_press_delay = 0;
delayed_press_keycode = KC_NO; delayed_press_keycode = KC_NO;
delayed_press_start_time = 0; delayed_press_start_time = 0;
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
stop_effects(); stop_effects();
#endif #endif
} }
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
static void start_delayed_press_with_effects( static void start_delayed_press_with_effects(fast_timer_t delay, uint16_t keycode, uint8_t r_color, uint8_t g_color, uint8_t b_color) {
const uint16_t delay,
const uint16_t keycode,
const uint8_t r_color,
const uint8_t g_color,
const uint8_t b_color) {
start_delayed_press(delay, keycode); start_delayed_press(delay, keycode);
start_effects(delay, r_color, g_color, b_color, increasing_effect); start_effects(delay, r_color, g_color, b_color, increasing_effect);
} }
@ -386,7 +341,7 @@ Effects when switching layers
static uint8_t previous_layer = UINT8_MAX; static uint8_t previous_layer = UINT8_MAX;
layer_state_t default_layer_state_set_user(layer_state_t state) { layer_state_t default_layer_state_set_user(layer_state_t state) {
const uint8_t current_layer = get_highest_layer(state); uint8_t current_layer = get_highest_layer(state);
if (previous_layer != current_layer) { if (previous_layer != current_layer) {
// For some reason, setting the default layer alone doesn't change it fully // For some reason, setting the default layer alone doesn't change it fully
layer_move(current_layer); layer_move(current_layer);
@ -407,50 +362,45 @@ layer_state_t default_layer_state_set_user(layer_state_t state) {
return state; return state;
} }
static void start_effects( static void start_effects(fast_timer_t max_duration, uint8_t r_color, uint8_t g_color, uint8_t b_color, float (*multiplier)(fast_timer_t)) {
const uint16_t max_duration, effect_r = r_color;
const uint8_t r_color, effect_g = g_color;
const uint8_t g_color, effect_b = b_color;
const uint8_t b_color, effect_multiplier = multiplier;
const float (*multiplier)(const uint16_t)) {
effect_r = r_color;
effect_g = g_color;
effect_b = b_color;
effect_multiplier = multiplier;
effect_max_duration = max_duration; effect_max_duration = max_duration;
effect_started_time = sync_timer_read(); effect_started_time = timer_read_fast();
} }
static void stop_effects(void) { static void stop_effects(void) {
effect_r = 0x0; effect_r = 0x0;
effect_g = 0x0; effect_g = 0x0;
effect_b = 0x0; effect_b = 0x0;
effect_multiplier = static_effect; effect_multiplier = static_effect;
effect_max_duration = EFFECTS_DURATION; effect_max_duration = EFFECTS_DURATION;
effect_started_time = 0; effect_started_time = 0;
} }
static float flashing_effect(const uint16_t delta_time) { static float flashing_effect(fast_timer_t delta_time) {
return ((delta_time / FLASHING_EFFECT_INTERVAL) + 1) & 0x01; return ((delta_time / FLASHING_EFFECT_INTERVAL) + 1) & 0x01;
} }
static float static_effect(const uint16_t delta_time) { static float static_effect(fast_timer_t delta_time) {
return 1.0; return 1.0;
} }
static float increasing_effect(const uint16_t delta_time) { static float increasing_effect(fast_timer_t delta_time) {
return MAX(0.0, MIN(1.0, ((float) delta_time) / effect_max_duration)); return ((float)delta_time) / effect_max_duration;
} }
bool rgb_matrix_indicators_user(void) { bool rgb_matrix_indicators_user(void) {
if (effect_started_time > 0) { if (effect_started_time > 0) {
const uint16_t delta_time = sync_timer_elapsed(effect_started_time); fast_timer_t delta_time = timer_elapsed_fast(effect_started_time);
if (delta_time <= effect_max_duration) { if (delta_time <= effect_max_duration) {
/* Render effect */ /* Render effect */
const float multiplier = effect_multiplier(delta_time); float multiplier = effect_multiplier(delta_time);
const uint8_t val_r = multiplier * effect_r; uint8_t val_r = multiplier * effect_r;
const uint8_t val_g = multiplier * effect_g; uint8_t val_g = multiplier * effect_g;
const uint8_t val_b = multiplier * effect_b; uint8_t val_b = multiplier * effect_b;
rgb_matrix_set_color_all(val_r, val_g, val_b); rgb_matrix_set_color_all(val_r, val_g, val_b);
return false; return false;
} else { } else {

17
keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/rules.mk
View file

@ -3,9 +3,20 @@
# Disabling MouseKey because it breaks my KVM switch # Disabling MouseKey because it breaks my KVM switch
MOUSEKEY_ENABLE = no MOUSEKEY_ENABLE = no
# Ensure sym_defer_g is used. # Use sym_eager_pk for better latency when gaming.
# It seems sym_defer_pk results in significant chattering, even with an 8ms debounce time. #
DEBOUNCE_TYPE = sym_defer_g # Previous issues with sym_defer_pk (and sym_eager_pk and debounce times
# shorter than 8ms) were due to Glorious' horrible hot-swap sockets.
# These issues were 100% resolved after I replaced them with Gateron hot-swap sockets.
#
# The old sockets apparently didn't hold onto the legs of the switches at all.
#
# Using eager might not be a good idea with other switch types, but I only use
# linears now, so this should be ok.
#
# asym_eager_defer_pk also works well and it is more resistant to chatter at
# the cost of delay when releasing a key being slightly higher.
DEBOUNCE_TYPE = sym_eager_pk
# Useful for debugging # Useful for debugging
# CONSOLE_ENABLE = yes # CONSOLE_ENABLE = yes