1 /* Copyright 2016-2017 Jack Humbert
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 2 of the License, or
6 * (at your option) any later version.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 #if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE)
24 #include "outputselect.h"
27 #ifndef BREATHING_PERIOD
28 #define BREATHING_PERIOD 6
31 #include "backlight.h"
32 extern backlight_config_t backlight_config;
34 #ifdef FAUXCLICKY_ENABLE
35 #include "fauxclicky.h"
43 #include "process_midi.h"
46 #ifdef VELOCIKEY_ENABLE
47 #include "velocikey.h"
60 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
63 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
66 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
68 float goodbye_song[][2] = GOODBYE_SONG;
69 float ag_norm_song[][2] = AG_NORM_SONG;
70 float ag_swap_song[][2] = AG_SWAP_SONG;
71 #ifdef DEFAULT_LAYER_SONGS
72 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
76 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
78 case QK_MODS ... QK_MODS_MAX:
93 if (code < QK_RMODS_MIN) return;
105 static inline void qk_register_weak_mods(uint8_t kc) {
106 add_weak_mods(MOD_BIT(kc));
107 send_keyboard_report();
110 static inline void qk_unregister_weak_mods(uint8_t kc) {
111 del_weak_mods(MOD_BIT(kc));
112 send_keyboard_report();
115 static inline void qk_register_mods(uint8_t kc) {
116 add_weak_mods(MOD_BIT(kc));
117 send_keyboard_report();
120 static inline void qk_unregister_mods(uint8_t kc) {
121 del_weak_mods(MOD_BIT(kc));
122 send_keyboard_report();
125 void register_code16 (uint16_t code) {
126 if (IS_MOD(code) || code == KC_NO) {
127 do_code16 (code, qk_register_mods);
129 do_code16 (code, qk_register_weak_mods);
131 register_code (code);
134 void unregister_code16 (uint16_t code) {
135 unregister_code (code);
136 if (IS_MOD(code) || code == KC_NO) {
137 do_code16 (code, qk_unregister_mods);
139 do_code16 (code, qk_unregister_weak_mods);
143 void tap_code16(uint16_t code) {
144 register_code16(code);
145 #if TAP_CODE_DELAY > 0
146 wait_ms(TAP_CODE_DELAY);
148 unregister_code16(code);
151 __attribute__ ((weak))
152 bool process_action_kb(keyrecord_t *record) {
156 __attribute__ ((weak))
157 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
158 return process_record_user(keycode, record);
161 __attribute__ ((weak))
162 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
166 void reset_keyboard(void) {
168 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
169 process_midi_all_notes_off();
172 #ifndef NO_MUSIC_MODE
173 music_all_notes_off();
175 uint16_t timer_start = timer_read();
176 PLAY_SONG(goodbye_song);
178 while(timer_elapsed(timer_start) < 250)
188 // this is also done later in bootloader.c - not sure if it's neccesary here
189 #ifdef BOOTLOADER_CATERINA
190 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
195 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
196 * Used to ensure that the correct keycode is released if the key is released.
198 static bool grave_esc_was_shifted = false;
200 /* Convert record into usable keycode via the contained event. */
201 uint16_t get_record_keycode(keyrecord_t *record) {
202 return get_event_keycode(record->event);
206 /* Convert event into usable keycode. Checks the layer cache to ensure that it
207 * retains the correct keycode after a layer change, if the key is still pressed.
209 uint16_t get_event_keycode(keyevent_t event) {
211 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
212 /* TODO: Use store_or_get_action() or a similar function. */
213 if (!disable_action_cache) {
217 layer = layer_switch_get_layer(event.key);
218 update_source_layers_cache(event.key, layer);
220 layer = read_source_layers_cache(event.key);
222 return keymap_key_to_keycode(layer, event.key);
225 return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
228 /* Main keycode processing function. Hands off handling to other functions,
229 * then processes internal Quantum keycodes, then processes ACTIONs.
231 bool process_record_quantum(keyrecord_t *record) {
232 uint16_t keycode = get_record_keycode(record);
234 // This is how you use actions here
235 // if (keycode == KC_LEAD) {
237 // action.code = ACTION_DEFAULT_LAYER_SET(0);
238 // process_action(record, action);
242 #ifdef VELOCIKEY_ENABLE
243 if (velocikey_enabled() && record->event.pressed) { velocikey_accelerate(); }
246 #ifdef TAP_DANCE_ENABLE
247 preprocess_tap_dance(keycode, record);
251 #if defined(KEY_LOCK_ENABLE)
252 // Must run first to be able to mask key_up events.
253 process_key_lock(&keycode, record) &&
255 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
256 process_clicky(keycode, record) &&
257 #endif //AUDIO_CLICKY
259 process_haptic(keycode, record) &&
260 #endif //HAPTIC_ENABLE
261 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYREACTIVE_ENABLED)
262 process_rgb_matrix(keycode, record) &&
264 process_record_kb(keycode, record) &&
265 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
266 process_midi(keycode, record) &&
269 process_audio(keycode, record) &&
272 process_steno(keycode, record) &&
274 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
275 process_music(keycode, record) &&
277 #ifdef TAP_DANCE_ENABLE
278 process_tap_dance(keycode, record) &&
280 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
281 process_unicode_common(keycode, record) &&
284 process_leader(keycode, record) &&
287 process_combo(keycode, record) &&
289 #ifdef PRINTING_ENABLE
290 process_printer(keycode, record) &&
292 #ifdef AUTO_SHIFT_ENABLE
293 process_auto_shift(keycode, record) &&
295 #ifdef TERMINAL_ENABLE
296 process_terminal(keycode, record) &&
298 #ifdef SPACE_CADET_ENABLE
299 process_space_cadet(keycode, record) &&
305 // Shift / paren setup
309 if (record->event.pressed) {
314 if (record->event.pressed) {
316 print("DEBUG: enabled.\n");
320 if (record->event.pressed) {
324 #ifdef FAUXCLICKY_ENABLE
326 if (record->event.pressed) {
331 if (record->event.pressed) {
336 if (record->event.pressed) {
341 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
343 // Split keyboards need to trigger on key-up for edge-case issue
344 #ifndef SPLIT_KEYBOARD
345 if (record->event.pressed) {
347 if (!record->event.pressed) {
352 case RGB_MODE_FORWARD:
353 if (record->event.pressed) {
354 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
356 rgblight_step_reverse();
363 case RGB_MODE_REVERSE:
364 if (record->event.pressed) {
365 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
370 rgblight_step_reverse();
375 // Split keyboards need to trigger on key-up for edge-case issue
376 #ifndef SPLIT_KEYBOARD
377 if (record->event.pressed) {
379 if (!record->event.pressed) {
381 rgblight_increase_hue();
385 // Split keyboards need to trigger on key-up for edge-case issue
386 #ifndef SPLIT_KEYBOARD
387 if (record->event.pressed) {
389 if (!record->event.pressed) {
391 rgblight_decrease_hue();
395 // Split keyboards need to trigger on key-up for edge-case issue
396 #ifndef SPLIT_KEYBOARD
397 if (record->event.pressed) {
399 if (!record->event.pressed) {
401 rgblight_increase_sat();
405 // Split keyboards need to trigger on key-up for edge-case issue
406 #ifndef SPLIT_KEYBOARD
407 if (record->event.pressed) {
409 if (!record->event.pressed) {
411 rgblight_decrease_sat();
415 // Split keyboards need to trigger on key-up for edge-case issue
416 #ifndef SPLIT_KEYBOARD
417 if (record->event.pressed) {
419 if (!record->event.pressed) {
421 rgblight_increase_val();
425 // Split keyboards need to trigger on key-up for edge-case issue
426 #ifndef SPLIT_KEYBOARD
427 if (record->event.pressed) {
429 if (!record->event.pressed) {
431 rgblight_decrease_val();
435 if (record->event.pressed) {
436 rgblight_increase_speed();
440 if (record->event.pressed) {
441 rgblight_decrease_speed();
445 if (record->event.pressed) {
446 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
449 case RGB_MODE_BREATHE:
450 #ifdef RGBLIGHT_EFFECT_BREATHING
451 if (record->event.pressed) {
452 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
453 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
456 rgblight_mode(RGBLIGHT_MODE_BREATHING);
461 case RGB_MODE_RAINBOW:
462 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
463 if (record->event.pressed) {
464 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
465 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
468 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
474 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
475 if (record->event.pressed) {
476 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
477 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
480 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
486 #ifdef RGBLIGHT_EFFECT_SNAKE
487 if (record->event.pressed) {
488 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
489 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
492 rgblight_mode(RGBLIGHT_MODE_SNAKE);
497 case RGB_MODE_KNIGHT:
498 #ifdef RGBLIGHT_EFFECT_KNIGHT
499 if (record->event.pressed) {
500 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
501 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
504 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
510 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
511 if (record->event.pressed) {
512 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
516 case RGB_MODE_GRADIENT:
517 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
518 if (record->event.pressed) {
519 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
520 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
523 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
528 case RGB_MODE_RGBTEST:
529 #ifdef RGBLIGHT_EFFECT_RGB_TEST
530 if (record->event.pressed) {
531 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
535 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
536 #ifdef VELOCIKEY_ENABLE
538 if (record->event.pressed) {
545 if (record->event.pressed) {
546 set_output(OUTPUT_AUTO);
550 if (record->event.pressed) {
551 set_output(OUTPUT_USB);
554 #ifdef BLUETOOTH_ENABLE
556 if (record->event.pressed) {
557 set_output(OUTPUT_BLUETOOTH);
562 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
563 if (record->event.pressed) {
564 // MAGIC actions (BOOTMAGIC without the boot)
565 if (!eeconfig_is_enabled()) {
569 keymap_config.raw = eeconfig_read_keymap();
572 case MAGIC_SWAP_CONTROL_CAPSLOCK:
573 keymap_config.swap_control_capslock = true;
575 case MAGIC_CAPSLOCK_TO_CONTROL:
576 keymap_config.capslock_to_control = true;
578 case MAGIC_SWAP_LALT_LGUI:
579 keymap_config.swap_lalt_lgui = true;
581 case MAGIC_SWAP_RALT_RGUI:
582 keymap_config.swap_ralt_rgui = true;
585 keymap_config.no_gui = true;
587 case MAGIC_SWAP_GRAVE_ESC:
588 keymap_config.swap_grave_esc = true;
590 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
591 keymap_config.swap_backslash_backspace = true;
593 case MAGIC_HOST_NKRO:
594 keymap_config.nkro = true;
596 case MAGIC_SWAP_ALT_GUI:
597 keymap_config.swap_lalt_lgui = true;
598 keymap_config.swap_ralt_rgui = true;
600 PLAY_SONG(ag_swap_song);
603 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
604 keymap_config.swap_control_capslock = false;
606 case MAGIC_UNCAPSLOCK_TO_CONTROL:
607 keymap_config.capslock_to_control = false;
609 case MAGIC_UNSWAP_LALT_LGUI:
610 keymap_config.swap_lalt_lgui = false;
612 case MAGIC_UNSWAP_RALT_RGUI:
613 keymap_config.swap_ralt_rgui = false;
616 keymap_config.no_gui = false;
618 case MAGIC_UNSWAP_GRAVE_ESC:
619 keymap_config.swap_grave_esc = false;
621 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
622 keymap_config.swap_backslash_backspace = false;
624 case MAGIC_UNHOST_NKRO:
625 keymap_config.nkro = false;
627 case MAGIC_UNSWAP_ALT_GUI:
628 keymap_config.swap_lalt_lgui = false;
629 keymap_config.swap_ralt_rgui = false;
631 PLAY_SONG(ag_norm_song);
634 case MAGIC_TOGGLE_ALT_GUI:
635 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
636 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
638 if (keymap_config.swap_ralt_rgui) {
639 PLAY_SONG(ag_swap_song);
641 PLAY_SONG(ag_norm_song);
645 case MAGIC_TOGGLE_NKRO:
646 keymap_config.nkro = !keymap_config.nkro;
651 eeconfig_update_keymap(keymap_config.raw);
652 clear_keyboard(); // clear to prevent stuck keys
659 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
660 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
662 #ifdef GRAVE_ESC_ALT_OVERRIDE
663 // if ALT is pressed, ESC is always sent
664 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
665 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
670 #ifdef GRAVE_ESC_CTRL_OVERRIDE
671 // if CTRL is pressed, ESC is always sent
672 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
673 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
678 #ifdef GRAVE_ESC_GUI_OVERRIDE
679 // if GUI is pressed, ESC is always sent
680 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
685 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
686 // if SHIFT is pressed, ESC is always sent
687 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
692 if (record->event.pressed) {
693 grave_esc_was_shifted = shifted;
694 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
697 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
700 send_keyboard_report();
704 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
706 if (record->event.pressed)
713 return process_action_kb(record);
716 __attribute__ ((weak))
717 const bool ascii_to_shift_lut[0x80] PROGMEM = {
718 0, 0, 0, 0, 0, 0, 0, 0,
719 0, 0, 0, 0, 0, 0, 0, 0,
720 0, 0, 0, 0, 0, 0, 0, 0,
721 0, 0, 0, 0, 0, 0, 0, 0,
722 0, 1, 1, 1, 1, 1, 1, 0,
723 1, 1, 1, 1, 0, 0, 0, 0,
724 0, 0, 0, 0, 0, 0, 0, 0,
725 0, 0, 1, 0, 1, 0, 1, 1,
726 1, 1, 1, 1, 1, 1, 1, 1,
727 1, 1, 1, 1, 1, 1, 1, 1,
728 1, 1, 1, 1, 1, 1, 1, 1,
729 1, 1, 1, 0, 0, 0, 1, 1,
730 0, 0, 0, 0, 0, 0, 0, 0,
731 0, 0, 0, 0, 0, 0, 0, 0,
732 0, 0, 0, 0, 0, 0, 0, 0,
733 0, 0, 0, 1, 1, 1, 1, 0
736 __attribute__ ((weak))
737 const bool ascii_to_altgr_lut[0x80] PROGMEM = {
738 0, 0, 0, 0, 0, 0, 0, 0,
739 0, 0, 0, 0, 0, 0, 0, 0,
740 0, 0, 0, 0, 0, 0, 0, 0,
741 0, 0, 0, 0, 0, 0, 0, 0,
742 0, 0, 0, 0, 0, 0, 0, 0,
743 0, 0, 0, 0, 0, 0, 0, 0,
744 0, 0, 0, 0, 0, 0, 0, 0,
745 0, 0, 0, 0, 0, 0, 0, 0,
746 0, 0, 0, 0, 0, 0, 0, 0,
747 0, 0, 0, 0, 0, 0, 0, 0,
748 0, 0, 0, 0, 0, 0, 0, 0,
749 0, 0, 0, 0, 0, 0, 0, 0,
750 0, 0, 0, 0, 0, 0, 0, 0,
751 0, 0, 0, 0, 0, 0, 0, 0,
752 0, 0, 0, 0, 0, 0, 0, 0,
753 0, 0, 0, 0, 0, 0, 0, 0
756 __attribute__ ((weak))
757 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
758 0, 0, 0, 0, 0, 0, 0, 0,
759 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
760 0, 0, 0, 0, 0, 0, 0, 0,
761 0, 0, 0, KC_ESC, 0, 0, 0, 0,
762 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
763 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
764 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
765 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
766 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
767 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
768 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
769 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
770 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
771 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
772 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
773 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
776 void send_string(const char *str) {
777 send_string_with_delay(str, 0);
780 void send_string_P(const char *str) {
781 send_string_with_delay_P(str, 0);
784 void send_string_with_delay(const char *str, uint8_t interval) {
786 char ascii_code = *str;
787 if (!ascii_code) break;
788 if (ascii_code == SS_TAP_CODE) {
790 uint8_t keycode = *(++str);
791 register_code(keycode);
792 unregister_code(keycode);
793 } else if (ascii_code == SS_DOWN_CODE) {
795 uint8_t keycode = *(++str);
796 register_code(keycode);
797 } else if (ascii_code == SS_UP_CODE) {
799 uint8_t keycode = *(++str);
800 unregister_code(keycode);
802 send_char(ascii_code);
806 { uint8_t ms = interval; while (ms--) wait_ms(1); }
810 void send_string_with_delay_P(const char *str, uint8_t interval) {
812 char ascii_code = pgm_read_byte(str);
813 if (!ascii_code) break;
814 if (ascii_code == SS_TAP_CODE) {
816 uint8_t keycode = pgm_read_byte(++str);
817 register_code(keycode);
818 unregister_code(keycode);
819 } else if (ascii_code == SS_DOWN_CODE) {
821 uint8_t keycode = pgm_read_byte(++str);
822 register_code(keycode);
823 } else if (ascii_code == SS_UP_CODE) {
825 uint8_t keycode = pgm_read_byte(++str);
826 unregister_code(keycode);
828 send_char(ascii_code);
832 { uint8_t ms = interval; while (ms--) wait_ms(1); }
836 void send_char(char ascii_code) {
837 uint8_t keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
838 bool is_shifted = pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code]);
839 bool is_altgred = pgm_read_byte(&ascii_to_altgr_lut[(uint8_t)ascii_code]);
842 register_code(KC_LSFT);
845 register_code(KC_RALT);
849 unregister_code(KC_RALT);
852 unregister_code(KC_LSFT);
856 void set_single_persistent_default_layer(uint8_t default_layer) {
857 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
858 PLAY_SONG(default_layer_songs[default_layer]);
860 eeconfig_update_default_layer(1U<<default_layer);
861 default_layer_set(1U<<default_layer);
864 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
865 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
866 uint32_t mask3 = 1UL << layer3;
867 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
870 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
871 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
874 void tap_random_base64(void) {
875 #if defined(__AVR_ATmega32U4__)
876 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
878 uint8_t key = rand() % 64;
882 register_code(KC_LSFT);
883 register_code(key + KC_A);
884 unregister_code(key + KC_A);
885 unregister_code(KC_LSFT);
888 register_code(key - 26 + KC_A);
889 unregister_code(key - 26 + KC_A);
893 unregister_code(KC_0);
896 register_code(key - 53 + KC_1);
897 unregister_code(key - 53 + KC_1);
900 register_code(KC_LSFT);
901 register_code(KC_EQL);
902 unregister_code(KC_EQL);
903 unregister_code(KC_LSFT);
906 register_code(KC_SLSH);
907 unregister_code(KC_SLSH);
912 __attribute__((weak))
913 void bootmagic_lite(void) {
914 // The lite version of TMK's bootmagic based on Wilba.
915 // 100% less potential for accidentally making the
916 // keyboard do stupid things.
918 // We need multiple scans because debouncing can't be turned off.
920 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
921 wait_ms(DEBOUNCING_DELAY * 2);
922 #elif defined(DEBOUNCE) && DEBOUNCE > 0
923 wait_ms(DEBOUNCE * 2);
929 // If the Esc and space bar are held down on power up,
930 // reset the EEPROM valid state and jump to bootloader.
931 // Assumes Esc is at [0,0].
932 // This isn't very generalized, but we need something that doesn't
933 // rely on user's keymaps in firmware or EEPROM.
934 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
936 // Jump to bootloader.
941 void matrix_init_quantum() {
942 #ifdef BOOTMAGIC_LITE
945 if (!eeconfig_is_enabled()) {
948 #ifdef BACKLIGHT_ENABLE
949 #ifdef LED_MATRIX_ENABLE
952 backlight_init_ports();
958 #ifdef RGB_MATRIX_ENABLE
961 #ifdef ENCODER_ENABLE
964 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
965 unicode_input_mode_init();
970 #ifdef OUTPUT_AUTO_ENABLE
971 set_output(OUTPUT_AUTO);
976 void matrix_scan_quantum() {
977 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
981 #ifdef TAP_DANCE_ENABLE
982 matrix_scan_tap_dance();
989 #if defined(BACKLIGHT_ENABLE)
990 #if defined(LED_MATRIX_ENABLE)
992 #elif defined(BACKLIGHT_PIN)
997 #ifdef RGB_MATRIX_ENABLE
1001 #ifdef ENCODER_ENABLE
1005 #ifdef HAPTIC_ENABLE
1011 #if defined(BACKLIGHT_ENABLE) && (defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS))
1013 // The logic is a bit complex, we support 3 setups:
1014 // 1. hardware PWM when backlight is wired to a PWM pin
1015 // depending on this pin, we use a different output compare unit
1016 // 2. software PWM with hardware timers, but the used timer depends
1017 // on the audio setup (audio wins other backlight)
1018 // 3. full software PWM
1020 #if BACKLIGHT_PIN == B7
1021 # define HARDWARE_PWM
1022 # define TCCRxA TCCR1A
1023 # define TCCRxB TCCR1B
1024 # define COMxx1 COM1C1
1025 # define OCRxx OCR1C
1027 #elif BACKLIGHT_PIN == B6
1028 # define HARDWARE_PWM
1029 # define TCCRxA TCCR1A
1030 # define TCCRxB TCCR1B
1031 # define COMxx1 COM1B1
1032 # define OCRxx OCR1B
1034 #elif BACKLIGHT_PIN == B5
1035 # define HARDWARE_PWM
1036 # define TCCRxA TCCR1A
1037 # define TCCRxB TCCR1B
1038 # define COMxx1 COM1A1
1039 # define OCRxx OCR1A
1041 #elif BACKLIGHT_PIN == C6
1042 # define HARDWARE_PWM
1043 # define TCCRxA TCCR3A
1044 # define TCCRxB TCCR3B
1045 # define COMxx1 COM1A1
1046 # define OCRxx OCR3A
1048 #elif defined(__AVR_ATmega32A__) && BACKLIGHT_PIN == D4
1049 # define TCCRxA TCCR1A
1050 # define TCCRxB TCCR1B
1051 # define COMxx1 COM1B1
1052 # define OCRxx OCR1B
1054 # define TIMSK1 TIMSK
1056 # if !defined(BACKLIGHT_CUSTOM_DRIVER)
1057 # if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO)
1058 // timer 1 is not used by audio , backlight can use it
1059 #pragma message "Using hardware timer 1 with software PWM"
1060 # define HARDWARE_PWM
1061 # define BACKLIGHT_PWM_TIMER
1062 # define TCCRxA TCCR1A
1063 # define TCCRxB TCCR1B
1064 # define OCRxx OCR1A
1065 # define OCRxAH OCR1AH
1066 # define OCRxAL OCR1AL
1067 # define TIMERx_COMPA_vect TIMER1_COMPA_vect
1068 # define TIMERx_OVF_vect TIMER1_OVF_vect
1069 # define OCIExA OCIE1A
1070 # define TOIEx TOIE1
1073 # define TIMSK TIMSK1
1075 # elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO)
1076 #pragma message "Using hardware timer 3 with software PWM"
1077 // timer 3 is not used by audio, backlight can use it
1078 # define HARDWARE_PWM
1079 # define BACKLIGHT_PWM_TIMER
1080 # define TCCRxA TCCR3A
1081 # define TCCRxB TCCR3B
1082 # define OCRxx OCR3A
1083 # define OCRxAH OCR3AH
1084 # define OCRxAL OCR3AL
1085 # define TIMERx_COMPA_vect TIMER3_COMPA_vect
1086 # define TIMERx_OVF_vect TIMER3_OVF_vect
1087 # define OCIExA OCIE3A
1088 # define TOIEx TOIE3
1091 # define TIMSK TIMSK3
1094 #pragma message "Audio in use - using pure software PWM"
1095 #define NO_HARDWARE_PWM
1098 #pragma message "Custom driver defined - using pure software PWM"
1099 #define NO_HARDWARE_PWM
1103 #ifndef BACKLIGHT_ON_STATE
1104 #define BACKLIGHT_ON_STATE 0
1107 void backlight_on(uint8_t backlight_pin) {
1108 #if BACKLIGHT_ON_STATE == 0
1109 writePinLow(backlight_pin);
1111 writePinHigh(backlight_pin);
1115 void backlight_off(uint8_t backlight_pin) {
1116 #if BACKLIGHT_ON_STATE == 0
1117 writePinHigh(backlight_pin);
1119 writePinLow(backlight_pin);
1124 #if defined(NO_HARDWARE_PWM) || defined(BACKLIGHT_PWM_TIMER) // pwm through software
1126 // we support multiple backlight pins
1127 #ifndef BACKLIGHT_LED_COUNT
1128 #define BACKLIGHT_LED_COUNT 1
1131 #if BACKLIGHT_LED_COUNT == 1
1132 #define BACKLIGHT_PIN_INIT { BACKLIGHT_PIN }
1134 #define BACKLIGHT_PIN_INIT BACKLIGHT_PINS
1137 #define FOR_EACH_LED(x) \
1138 for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) \
1140 uint8_t backlight_pin = backlight_pins[i]; \
1146 static const uint8_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT;
1148 #else // full hardware PWM
1150 // we support only one backlight pin
1151 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1152 #define FOR_EACH_LED(x) x
1156 #ifdef NO_HARDWARE_PWM
1157 __attribute__((weak))
1158 void backlight_init_ports(void)
1160 // Setup backlight pin as output and output to on state.
1162 setPinOutput(backlight_pin);
1163 backlight_on(backlight_pin);
1167 __attribute__ ((weak))
1168 void backlight_set(uint8_t level) {}
1170 uint8_t backlight_tick = 0;
1172 #ifndef BACKLIGHT_CUSTOM_DRIVER
1173 void backlight_task(void) {
1174 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1176 backlight_on(backlight_pin);
1181 backlight_off(backlight_pin);
1184 backlight_tick = (backlight_tick + 1) % 16;
1188 #ifdef BACKLIGHT_BREATHING
1189 #ifndef BACKLIGHT_CUSTOM_DRIVER
1190 #error "Backlight breathing only available with hardware PWM. Please disable."
1194 #else // hardware pwm through timer
1196 #ifdef BACKLIGHT_PWM_TIMER
1198 // The idea of software PWM assisted by hardware timers is the following
1199 // we use the hardware timer in fast PWM mode like for hardware PWM, but
1200 // instead of letting the Output Match Comparator control the led pin
1201 // (which is not possible since the backlight is not wired to PWM pins on the
1202 // CPU), we do the LED on/off by oursleves.
1203 // The timer is setup to count up to 0xFFFF, and we set the Output Compare
1204 // register to the current 16bits backlight level (after CIE correction).
1205 // This means the CPU will trigger a compare match interrupt when the counter
1206 // reaches the backlight level, where we turn off the LEDs,
1207 // but also an overflow interrupt when the counter rolls back to 0,
1208 // in which we're going to turn on the LEDs.
1209 // The LED will then be on for OCRxx/0xFFFF time, adjusted every 244Hz.
1211 // Triggered when the counter reaches the OCRx value
1212 ISR(TIMERx_COMPA_vect) {
1214 backlight_off(backlight_pin);
1218 // Triggered when the counter reaches the TOP value
1219 // this one triggers at F_CPU/65536 =~ 244 Hz
1220 ISR(TIMERx_OVF_vect) {
1221 #ifdef BACKLIGHT_BREATHING
1224 // for very small values of OCRxx (or backlight level)
1225 // we can't guarantee this whole code won't execute
1226 // at the same time as the compare match interrupt
1227 // which means that we might turn on the leds while
1228 // trying to turn them off, leading to flickering
1229 // artifacts (especially while breathing, because breathing_task
1230 // takes many computation cycles).
1231 // so better not turn them on while the counter TOP is very low.
1234 backlight_on(backlight_pin);
1241 #define TIMER_TOP 0xFFFFU
1243 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1244 static uint16_t cie_lightness(uint16_t v) {
1245 if (v <= 5243) // if below 8% of max
1246 return v / 9; // same as dividing by 900%
1248 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1249 // to get a useful result with integer division, we shift left in the expression above
1250 // and revert what we've done again after squaring.
1252 if (y > 0xFFFFUL) // prevent overflow
1255 return (uint16_t) y;
1259 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1260 static inline void set_pwm(uint16_t val) {
1264 #ifndef BACKLIGHT_CUSTOM_DRIVER
1265 __attribute__ ((weak))
1266 void backlight_set(uint8_t level) {
1267 if (level > BACKLIGHT_LEVELS)
1268 level = BACKLIGHT_LEVELS;
1271 #ifdef BACKLIGHT_PWM_TIMER
1273 TIMSK &= ~(_BV(OCIExA));
1274 TIMSK &= ~(_BV(TOIEx));
1276 backlight_off(backlight_pin);
1280 // Turn off PWM control on backlight pin
1281 TCCRxA &= ~(_BV(COMxx1));
1284 #ifdef BACKLIGHT_PWM_TIMER
1286 TIMSK |= _BV(OCIExA);
1287 TIMSK |= _BV(TOIEx);
1290 // Turn on PWM control of backlight pin
1291 TCCRxA |= _BV(COMxx1);
1294 // Set the brightness
1295 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1298 void backlight_task(void) {}
1299 #endif // BACKLIGHT_CUSTOM_DRIVER
1301 #ifdef BACKLIGHT_BREATHING
1303 #define BREATHING_NO_HALT 0
1304 #define BREATHING_HALT_OFF 1
1305 #define BREATHING_HALT_ON 2
1306 #define BREATHING_STEPS 128
1308 static uint8_t breathing_period = BREATHING_PERIOD;
1309 static uint8_t breathing_halt = BREATHING_NO_HALT;
1310 static uint16_t breathing_counter = 0;
1312 #ifdef BACKLIGHT_PWM_TIMER
1313 static bool breathing = false;
1315 bool is_breathing(void) {
1319 #define breathing_interrupt_enable() do { breathing = true; } while (0)
1320 #define breathing_interrupt_disable() do { breathing = false; } while (0)
1323 bool is_breathing(void) {
1324 return !!(TIMSK1 & _BV(TOIE1));
1327 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1328 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1331 #define breathing_min() do {breathing_counter = 0;} while (0)
1332 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1334 void breathing_enable(void)
1336 breathing_counter = 0;
1337 breathing_halt = BREATHING_NO_HALT;
1338 breathing_interrupt_enable();
1341 void breathing_pulse(void)
1343 if (get_backlight_level() == 0)
1347 breathing_halt = BREATHING_HALT_ON;
1348 breathing_interrupt_enable();
1351 void breathing_disable(void)
1353 breathing_interrupt_disable();
1354 // Restore backlight level
1355 backlight_set(get_backlight_level());
1358 void breathing_self_disable(void)
1360 if (get_backlight_level() == 0)
1361 breathing_halt = BREATHING_HALT_OFF;
1363 breathing_halt = BREATHING_HALT_ON;
1366 void breathing_toggle(void) {
1368 breathing_disable();
1373 void breathing_period_set(uint8_t value)
1377 breathing_period = value;
1380 void breathing_period_default(void) {
1381 breathing_period_set(BREATHING_PERIOD);
1384 void breathing_period_inc(void)
1386 breathing_period_set(breathing_period+1);
1389 void breathing_period_dec(void)
1391 breathing_period_set(breathing_period-1);
1394 /* To generate breathing curve in python:
1395 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1397 static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1399 // Use this before the cie_lightness function.
1400 static inline uint16_t scale_backlight(uint16_t v) {
1401 return v / BACKLIGHT_LEVELS * get_backlight_level();
1404 #ifdef BACKLIGHT_PWM_TIMER
1405 void breathing_task(void)
1407 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1408 * about 244 times per second.
1410 ISR(TIMER1_OVF_vect)
1413 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1414 // resetting after one period to prevent ugly reset at overflow.
1415 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1416 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1418 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1419 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1421 breathing_interrupt_disable();
1424 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1427 #endif // BACKLIGHT_BREATHING
1429 __attribute__ ((weak))
1430 void backlight_init_ports(void)
1432 // Setup backlight pin as output and output to on state.
1434 setPinOutput(backlight_pin);
1435 backlight_on(backlight_pin);
1438 // I could write a wall of text here to explain... but TL;DW
1439 // Go read the ATmega32u4 datasheet.
1440 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1442 #ifdef BACKLIGHT_PWM_TIMER
1443 // TimerX setup, Fast PWM mode count to TOP set in ICRx
1444 TCCRxA = _BV(WGM11); // = 0b00000010;
1445 // clock select clk/1
1446 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1447 #else // hardware PWM
1448 // Pin PB7 = OCR1C (Timer 1, Channel C)
1449 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1450 // (i.e. start high, go low when counter matches.)
1451 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1452 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1456 "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]."
1457 "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)."
1459 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1460 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1462 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1466 #ifdef BACKLIGHT_BREATHING
1471 #endif // hardware backlight
1473 #else // no backlight
1475 __attribute__ ((weak))
1476 void backlight_init_ports(void) {}
1478 __attribute__ ((weak))
1479 void backlight_set(uint8_t level) {}
1483 #ifdef HD44780_ENABLED
1484 #include "hd44780.h"
1488 // Functions for spitting out values
1491 void send_dword(uint32_t number) { // this might not actually work
1492 uint16_t word = (number >> 16);
1494 send_word(number & 0xFFFFUL);
1497 void send_word(uint16_t number) {
1498 uint8_t byte = number >> 8;
1500 send_byte(number & 0xFF);
1503 void send_byte(uint8_t number) {
1504 uint8_t nibble = number >> 4;
1505 send_nibble(nibble);
1506 send_nibble(number & 0xF);
1509 void send_nibble(uint8_t number) {
1512 register_code(KC_0);
1513 unregister_code(KC_0);
1516 register_code(KC_1 + (number - 1));
1517 unregister_code(KC_1 + (number - 1));
1520 register_code(KC_A + (number - 0xA));
1521 unregister_code(KC_A + (number - 0xA));
1527 __attribute__((weak))
1528 uint16_t hex_to_keycode(uint8_t hex)
1533 } else if (hex < 0xA) {
1534 return KC_1 + (hex - 0x1);
1536 return KC_A + (hex - 0xA);
1540 void api_send_unicode(uint32_t unicode) {
1543 dword_to_bytes(unicode, chunk);
1544 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1548 __attribute__ ((weak))
1549 void led_set_user(uint8_t usb_led) {
1553 __attribute__ ((weak))
1554 void led_set_kb(uint8_t usb_led) {
1555 led_set_user(usb_led);
1558 __attribute__ ((weak))
1559 void led_init_ports(void)
1564 __attribute__ ((weak))
1565 void led_set(uint8_t usb_led)
1570 // // Using PE6 Caps Lock LED
1571 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1581 // PORTE &= ~(1<<6);
1584 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1585 // Use backlight as Caps Lock indicator
1586 uint8_t bl_toggle_lvl = 0;
1588 if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1589 // Turning Caps Lock ON and backlight is disabled in config
1590 // Toggling backlight to the brightest level
1591 bl_toggle_lvl = BACKLIGHT_LEVELS;
1592 } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1593 // Turning Caps Lock OFF and backlight is enabled in config
1594 // Toggling backlight and restoring config level
1595 bl_toggle_lvl = backlight_config.level;
1598 // Set level without modify backlight_config to keep ability to restore state
1599 backlight_set(bl_toggle_lvl);
1602 led_set_kb(usb_led);
1606 //------------------------------------------------------------------------------
1607 // Override these functions in your keymap file to play different tunes on
1608 // different events such as startup and bootloader jump
1610 __attribute__ ((weak))
1611 void startup_user() {}
1613 __attribute__ ((weak))
1614 void shutdown_user() {}
1616 //------------------------------------------------------------------------------