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 #include "outputselect.h"
23 #define TAPPING_TERM 200
26 #ifndef BREATHING_PERIOD
27 #define BREATHING_PERIOD 6
30 #include "backlight.h"
31 extern backlight_config_t backlight_config;
33 #ifdef FAUXCLICKY_ENABLE
34 #include "fauxclicky.h"
42 #include "process_midi.h"
52 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
55 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
58 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
60 float goodbye_song[][2] = GOODBYE_SONG;
61 float ag_norm_song[][2] = AG_NORM_SONG;
62 float ag_swap_song[][2] = AG_SWAP_SONG;
63 #ifdef DEFAULT_LAYER_SONGS
64 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
68 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
70 case QK_MODS ... QK_MODS_MAX:
85 if (code < QK_RMODS_MIN) return;
97 static inline void qk_register_weak_mods(uint8_t kc) {
98 add_weak_mods(MOD_BIT(kc));
99 send_keyboard_report();
102 static inline void qk_unregister_weak_mods(uint8_t kc) {
103 del_weak_mods(MOD_BIT(kc));
104 send_keyboard_report();
107 static inline void qk_register_mods(uint8_t kc) {
108 add_weak_mods(MOD_BIT(kc));
109 send_keyboard_report();
112 static inline void qk_unregister_mods(uint8_t kc) {
113 del_weak_mods(MOD_BIT(kc));
114 send_keyboard_report();
117 void register_code16 (uint16_t code) {
118 if (IS_MOD(code) || code == KC_NO) {
119 do_code16 (code, qk_register_mods);
121 do_code16 (code, qk_register_weak_mods);
123 register_code (code);
126 void unregister_code16 (uint16_t code) {
127 unregister_code (code);
128 if (IS_MOD(code) || code == KC_NO) {
129 do_code16 (code, qk_unregister_mods);
131 do_code16 (code, qk_unregister_weak_mods);
135 void tap_code16(uint16_t code) {
136 register_code16(code);
137 #if TAP_CODE_DELAY > 0
138 wait_ms(TAP_CODE_DELAY);
140 unregister_code16(code);
143 __attribute__ ((weak))
144 bool process_action_kb(keyrecord_t *record) {
148 __attribute__ ((weak))
149 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
150 return process_record_user(keycode, record);
153 __attribute__ ((weak))
154 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
158 void reset_keyboard(void) {
160 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
161 process_midi_all_notes_off();
164 #ifndef NO_MUSIC_MODE
165 music_all_notes_off();
167 uint16_t timer_start = timer_read();
168 PLAY_SONG(goodbye_song);
170 while(timer_elapsed(timer_start) < 250)
177 // this is also done later in bootloader.c - not sure if it's neccesary here
178 #ifdef BOOTLOADER_CATERINA
179 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
184 // Shift / paren setup
187 #define LSPO_KEY KC_9
190 #define RSPC_KEY KC_0
193 // Shift / Enter setup
195 #define SFTENT_KEY KC_ENT
198 static bool shift_interrupted[2] = {0, 0};
199 static uint16_t scs_timer[2] = {0, 0};
201 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
202 * Used to ensure that the correct keycode is released if the key is released.
204 static bool grave_esc_was_shifted = false;
206 bool process_record_quantum(keyrecord_t *record) {
208 /* This gets the keycode from the key pressed */
209 keypos_t key = record->event.key;
212 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
213 /* TODO: Use store_or_get_action() or a similar function. */
214 if (!disable_action_cache) {
217 if (record->event.pressed) {
218 layer = layer_switch_get_layer(key);
219 update_source_layers_cache(key, layer);
221 layer = read_source_layers_cache(key);
223 keycode = keymap_key_to_keycode(layer, key);
226 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
228 // This is how you use actions here
229 // if (keycode == KC_LEAD) {
231 // action.code = ACTION_DEFAULT_LAYER_SET(0);
232 // process_action(record, action);
236 #ifdef TAP_DANCE_ENABLE
237 preprocess_tap_dance(keycode, record);
241 #if defined(KEY_LOCK_ENABLE)
242 // Must run first to be able to mask key_up events.
243 process_key_lock(&keycode, record) &&
245 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
246 process_clicky(keycode, record) &&
247 #endif //AUDIO_CLICKY
248 process_record_kb(keycode, record) &&
249 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
250 process_rgb_matrix(keycode, record) &&
252 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
253 process_midi(keycode, record) &&
256 process_audio(keycode, record) &&
259 process_steno(keycode, record) &&
261 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
262 process_music(keycode, record) &&
264 #ifdef TAP_DANCE_ENABLE
265 process_tap_dance(keycode, record) &&
267 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
268 process_unicode_common(keycode, record) &&
271 process_leader(keycode, record) &&
274 process_combo(keycode, record) &&
276 #ifdef PRINTING_ENABLE
277 process_printer(keycode, record) &&
279 #ifdef AUTO_SHIFT_ENABLE
280 process_auto_shift(keycode, record) &&
282 #ifdef TERMINAL_ENABLE
283 process_terminal(keycode, record) &&
289 // Shift / paren setup
293 if (record->event.pressed) {
298 if (record->event.pressed) {
300 print("DEBUG: enabled.\n");
304 if (record->event.pressed) {
308 #ifdef FAUXCLICKY_ENABLE
310 if (record->event.pressed) {
315 if (record->event.pressed) {
320 if (record->event.pressed) {
325 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
327 // Split keyboards need to trigger on key-up for edge-case issue
328 #ifndef SPLIT_KEYBOARD
329 if (record->event.pressed) {
331 if (!record->event.pressed) {
334 #ifdef SPLIT_KEYBOARD
339 case RGB_MODE_FORWARD:
340 if (record->event.pressed) {
341 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
343 rgblight_step_reverse();
348 #ifdef SPLIT_KEYBOARD
353 case RGB_MODE_REVERSE:
354 if (record->event.pressed) {
355 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
360 rgblight_step_reverse();
362 #ifdef SPLIT_KEYBOARD
368 // Split keyboards need to trigger on key-up for edge-case issue
369 #ifndef SPLIT_KEYBOARD
370 if (record->event.pressed) {
372 if (!record->event.pressed) {
374 rgblight_increase_hue();
375 #ifdef SPLIT_KEYBOARD
381 // Split keyboards need to trigger on key-up for edge-case issue
382 #ifndef SPLIT_KEYBOARD
383 if (record->event.pressed) {
385 if (!record->event.pressed) {
387 rgblight_decrease_hue();
388 #ifdef SPLIT_KEYBOARD
394 // Split keyboards need to trigger on key-up for edge-case issue
395 #ifndef SPLIT_KEYBOARD
396 if (record->event.pressed) {
398 if (!record->event.pressed) {
400 rgblight_increase_sat();
401 #ifdef SPLIT_KEYBOARD
407 // Split keyboards need to trigger on key-up for edge-case issue
408 #ifndef SPLIT_KEYBOARD
409 if (record->event.pressed) {
411 if (!record->event.pressed) {
413 rgblight_decrease_sat();
414 #ifdef SPLIT_KEYBOARD
420 // Split keyboards need to trigger on key-up for edge-case issue
421 #ifndef SPLIT_KEYBOARD
422 if (record->event.pressed) {
424 if (!record->event.pressed) {
426 rgblight_increase_val();
427 #ifdef SPLIT_KEYBOARD
433 // Split keyboards need to trigger on key-up for edge-case issue
434 #ifndef SPLIT_KEYBOARD
435 if (record->event.pressed) {
437 if (!record->event.pressed) {
439 rgblight_decrease_val();
440 #ifdef SPLIT_KEYBOARD
446 if (record->event.pressed) {
447 rgblight_increase_speed();
451 if (record->event.pressed) {
452 rgblight_decrease_speed();
456 if (record->event.pressed) {
457 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
458 #ifdef SPLIT_KEYBOARD
463 case RGB_MODE_BREATHE:
464 #ifdef RGBLIGHT_EFFECT_BREATHING
465 if (record->event.pressed) {
466 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
467 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
470 rgblight_mode(RGBLIGHT_MODE_BREATHING);
475 case RGB_MODE_RAINBOW:
476 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
477 if (record->event.pressed) {
478 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
479 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
482 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
488 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
489 if (record->event.pressed) {
490 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
491 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
494 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
500 #ifdef RGBLIGHT_EFFECT_SNAKE
501 if (record->event.pressed) {
502 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
503 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
506 rgblight_mode(RGBLIGHT_MODE_SNAKE);
511 case RGB_MODE_KNIGHT:
512 #ifdef RGBLIGHT_EFFECT_KNIGHT
513 if (record->event.pressed) {
514 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
515 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
518 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
524 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
525 if (record->event.pressed) {
526 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
530 case RGB_MODE_GRADIENT:
531 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
532 if (record->event.pressed) {
533 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
534 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
537 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
542 case RGB_MODE_RGBTEST:
543 #ifdef RGBLIGHT_EFFECT_RGB_TEST
544 if (record->event.pressed) {
545 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
549 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
552 if (record->event.pressed) {
553 set_output(OUTPUT_AUTO);
557 if (record->event.pressed) {
558 set_output(OUTPUT_USB);
561 #ifdef BLUETOOTH_ENABLE
563 if (record->event.pressed) {
564 set_output(OUTPUT_BLUETOOTH);
569 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
570 if (record->event.pressed) {
571 // MAGIC actions (BOOTMAGIC without the boot)
572 if (!eeconfig_is_enabled()) {
576 keymap_config.raw = eeconfig_read_keymap();
579 case MAGIC_SWAP_CONTROL_CAPSLOCK:
580 keymap_config.swap_control_capslock = true;
582 case MAGIC_CAPSLOCK_TO_CONTROL:
583 keymap_config.capslock_to_control = true;
585 case MAGIC_SWAP_LALT_LGUI:
586 keymap_config.swap_lalt_lgui = true;
588 case MAGIC_SWAP_RALT_RGUI:
589 keymap_config.swap_ralt_rgui = true;
592 keymap_config.no_gui = true;
594 case MAGIC_SWAP_GRAVE_ESC:
595 keymap_config.swap_grave_esc = true;
597 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
598 keymap_config.swap_backslash_backspace = true;
600 case MAGIC_HOST_NKRO:
601 keymap_config.nkro = true;
603 case MAGIC_SWAP_ALT_GUI:
604 keymap_config.swap_lalt_lgui = true;
605 keymap_config.swap_ralt_rgui = true;
607 PLAY_SONG(ag_swap_song);
610 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
611 keymap_config.swap_control_capslock = false;
613 case MAGIC_UNCAPSLOCK_TO_CONTROL:
614 keymap_config.capslock_to_control = false;
616 case MAGIC_UNSWAP_LALT_LGUI:
617 keymap_config.swap_lalt_lgui = false;
619 case MAGIC_UNSWAP_RALT_RGUI:
620 keymap_config.swap_ralt_rgui = false;
623 keymap_config.no_gui = false;
625 case MAGIC_UNSWAP_GRAVE_ESC:
626 keymap_config.swap_grave_esc = false;
628 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
629 keymap_config.swap_backslash_backspace = false;
631 case MAGIC_UNHOST_NKRO:
632 keymap_config.nkro = false;
634 case MAGIC_UNSWAP_ALT_GUI:
635 keymap_config.swap_lalt_lgui = false;
636 keymap_config.swap_ralt_rgui = false;
638 PLAY_SONG(ag_norm_song);
641 case MAGIC_TOGGLE_ALT_GUI:
642 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
643 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
645 if (keymap_config.swap_ralt_rgui) {
646 PLAY_SONG(ag_swap_song);
648 PLAY_SONG(ag_norm_song);
652 case MAGIC_TOGGLE_NKRO:
653 keymap_config.nkro = !keymap_config.nkro;
658 eeconfig_update_keymap(keymap_config.raw);
659 clear_keyboard(); // clear to prevent stuck keys
665 if (record->event.pressed) {
666 shift_interrupted[0] = false;
667 scs_timer[0] = timer_read ();
668 register_mods(MOD_BIT(KC_LSFT));
671 #ifdef DISABLE_SPACE_CADET_ROLLOVER
672 if (get_mods() & MOD_BIT(KC_RSFT)) {
673 shift_interrupted[0] = true;
674 shift_interrupted[1] = true;
677 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
678 register_code(LSPO_KEY);
679 unregister_code(LSPO_KEY);
681 unregister_mods(MOD_BIT(KC_LSFT));
687 if (record->event.pressed) {
688 shift_interrupted[1] = false;
689 scs_timer[1] = timer_read ();
690 register_mods(MOD_BIT(KC_RSFT));
693 #ifdef DISABLE_SPACE_CADET_ROLLOVER
694 if (get_mods() & MOD_BIT(KC_LSFT)) {
695 shift_interrupted[0] = true;
696 shift_interrupted[1] = true;
699 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
700 register_code(RSPC_KEY);
701 unregister_code(RSPC_KEY);
703 unregister_mods(MOD_BIT(KC_RSFT));
709 if (record->event.pressed) {
710 shift_interrupted[1] = false;
711 scs_timer[1] = timer_read ();
712 register_mods(MOD_BIT(KC_RSFT));
714 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
715 unregister_mods(MOD_BIT(KC_RSFT));
716 register_code(SFTENT_KEY);
717 unregister_code(SFTENT_KEY);
720 unregister_mods(MOD_BIT(KC_RSFT));
726 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
727 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
729 #ifdef GRAVE_ESC_ALT_OVERRIDE
730 // if ALT is pressed, ESC is always sent
731 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
732 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
737 #ifdef GRAVE_ESC_CTRL_OVERRIDE
738 // if CTRL is pressed, ESC is always sent
739 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
740 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
745 #ifdef GRAVE_ESC_GUI_OVERRIDE
746 // if GUI is pressed, ESC is always sent
747 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
752 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
753 // if SHIFT is pressed, ESC is always sent
754 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
759 if (record->event.pressed) {
760 grave_esc_was_shifted = shifted;
761 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
764 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
767 send_keyboard_report();
771 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
773 if (record->event.pressed)
780 shift_interrupted[0] = true;
781 shift_interrupted[1] = true;
786 return process_action_kb(record);
789 __attribute__ ((weak))
790 const bool ascii_to_shift_lut[0x80] PROGMEM = {
791 0, 0, 0, 0, 0, 0, 0, 0,
792 0, 0, 0, 0, 0, 0, 0, 0,
793 0, 0, 0, 0, 0, 0, 0, 0,
794 0, 0, 0, 0, 0, 0, 0, 0,
795 0, 1, 1, 1, 1, 1, 1, 0,
796 1, 1, 1, 1, 0, 0, 0, 0,
797 0, 0, 0, 0, 0, 0, 0, 0,
798 0, 0, 1, 0, 1, 0, 1, 1,
799 1, 1, 1, 1, 1, 1, 1, 1,
800 1, 1, 1, 1, 1, 1, 1, 1,
801 1, 1, 1, 1, 1, 1, 1, 1,
802 1, 1, 1, 0, 0, 0, 1, 1,
803 0, 0, 0, 0, 0, 0, 0, 0,
804 0, 0, 0, 0, 0, 0, 0, 0,
805 0, 0, 0, 0, 0, 0, 0, 0,
806 0, 0, 0, 1, 1, 1, 1, 0
809 __attribute__ ((weak))
810 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
811 0, 0, 0, 0, 0, 0, 0, 0,
812 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
813 0, 0, 0, 0, 0, 0, 0, 0,
814 0, 0, 0, KC_ESC, 0, 0, 0, 0,
815 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
816 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
817 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
818 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
819 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
820 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
821 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
822 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
823 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
824 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
825 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
826 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
829 void send_string(const char *str) {
830 send_string_with_delay(str, 0);
833 void send_string_P(const char *str) {
834 send_string_with_delay_P(str, 0);
837 void send_string_with_delay(const char *str, uint8_t interval) {
839 char ascii_code = *str;
840 if (!ascii_code) break;
841 if (ascii_code == 1) {
843 uint8_t keycode = *(++str);
844 register_code(keycode);
845 unregister_code(keycode);
846 } else if (ascii_code == 2) {
848 uint8_t keycode = *(++str);
849 register_code(keycode);
850 } else if (ascii_code == 3) {
852 uint8_t keycode = *(++str);
853 unregister_code(keycode);
855 send_char(ascii_code);
859 { uint8_t ms = interval; while (ms--) wait_ms(1); }
863 void send_string_with_delay_P(const char *str, uint8_t interval) {
865 char ascii_code = pgm_read_byte(str);
866 if (!ascii_code) break;
867 if (ascii_code == 1) {
869 uint8_t keycode = pgm_read_byte(++str);
870 register_code(keycode);
871 unregister_code(keycode);
872 } else if (ascii_code == 2) {
874 uint8_t keycode = pgm_read_byte(++str);
875 register_code(keycode);
876 } else if (ascii_code == 3) {
878 uint8_t keycode = pgm_read_byte(++str);
879 unregister_code(keycode);
881 send_char(ascii_code);
885 { uint8_t ms = interval; while (ms--) wait_ms(1); }
889 void send_char(char ascii_code) {
891 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
892 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
893 register_code(KC_LSFT);
894 register_code(keycode);
895 unregister_code(keycode);
896 unregister_code(KC_LSFT);
898 register_code(keycode);
899 unregister_code(keycode);
903 void set_single_persistent_default_layer(uint8_t default_layer) {
904 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
905 PLAY_SONG(default_layer_songs[default_layer]);
907 eeconfig_update_default_layer(1U<<default_layer);
908 default_layer_set(1U<<default_layer);
911 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
912 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
913 uint32_t mask3 = 1UL << layer3;
914 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
917 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
918 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
921 void tap_random_base64(void) {
922 #if defined(__AVR_ATmega32U4__)
923 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
925 uint8_t key = rand() % 64;
929 register_code(KC_LSFT);
930 register_code(key + KC_A);
931 unregister_code(key + KC_A);
932 unregister_code(KC_LSFT);
935 register_code(key - 26 + KC_A);
936 unregister_code(key - 26 + KC_A);
940 unregister_code(KC_0);
943 register_code(key - 53 + KC_1);
944 unregister_code(key - 53 + KC_1);
947 register_code(KC_LSFT);
948 register_code(KC_EQL);
949 unregister_code(KC_EQL);
950 unregister_code(KC_LSFT);
953 register_code(KC_SLSH);
954 unregister_code(KC_SLSH);
959 __attribute__((weak))
960 void bootmagic_lite(void) {
961 // The lite version of TMK's bootmagic based on Wilba.
962 // 100% less potential for accidentally making the
963 // keyboard do stupid things.
965 // We need multiple scans because debouncing can't be turned off.
967 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
968 wait_ms(DEBOUNCING_DELAY * 2);
969 #elif defined(DEBOUNCE) && DEBOUNCE > 0
970 wait_ms(DEBOUNCE * 2);
976 // If the Esc and space bar are held down on power up,
977 // reset the EEPROM valid state and jump to bootloader.
978 // Assumes Esc is at [0,0].
979 // This isn't very generalized, but we need something that doesn't
980 // rely on user's keymaps in firmware or EEPROM.
981 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
983 // Jump to bootloader.
988 void matrix_init_quantum() {
989 #ifdef BOOTMAGIC_LITE
992 if (!eeconfig_is_enabled()) {
995 #ifdef BACKLIGHT_ENABLE
996 backlight_init_ports();
1001 #ifdef RGB_MATRIX_ENABLE
1004 #ifdef ENCODER_ENABLE
1007 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1008 unicode_input_mode_init();
1013 uint8_t rgb_matrix_task_counter = 0;
1015 #ifndef RGB_MATRIX_SKIP_FRAMES
1016 #define RGB_MATRIX_SKIP_FRAMES 1
1019 void matrix_scan_quantum() {
1020 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1021 matrix_scan_music();
1024 #ifdef TAP_DANCE_ENABLE
1025 matrix_scan_tap_dance();
1029 matrix_scan_combo();
1032 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1036 #ifdef RGB_MATRIX_ENABLE
1038 if (rgb_matrix_task_counter == 0) {
1039 rgb_matrix_update_pwm_buffers();
1041 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1044 #ifdef ENCODER_ENABLE
1050 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1052 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1054 // depending on the pin, we use a different output compare unit
1055 #if BACKLIGHT_PIN == B7
1056 # define TCCRxA TCCR1A
1057 # define TCCRxB TCCR1B
1058 # define COMxx1 COM1C1
1059 # define OCRxx OCR1C
1061 #elif BACKLIGHT_PIN == B6
1062 # define TCCRxA TCCR1A
1063 # define TCCRxB TCCR1B
1064 # define COMxx1 COM1B1
1065 # define OCRxx OCR1B
1067 #elif BACKLIGHT_PIN == B5
1068 # define TCCRxA TCCR1A
1069 # define TCCRxB TCCR1B
1070 # define COMxx1 COM1A1
1071 # define OCRxx OCR1A
1073 #elif BACKLIGHT_PIN == C6
1074 # define TCCRxA TCCR3A
1075 # define TCCRxB TCCR3B
1076 # define COMxx1 COM1A1
1077 # define OCRxx OCR3A
1080 # define NO_HARDWARE_PWM
1083 #ifndef BACKLIGHT_ON_STATE
1084 #define BACKLIGHT_ON_STATE 0
1087 #ifdef NO_HARDWARE_PWM // pwm through software
1089 __attribute__ ((weak))
1090 void backlight_init_ports(void)
1092 // Setup backlight pin as output and output to on state.
1094 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1095 #if BACKLIGHT_ON_STATE == 0
1097 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1100 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1104 __attribute__ ((weak))
1105 void backlight_set(uint8_t level) {}
1107 uint8_t backlight_tick = 0;
1109 #ifndef BACKLIGHT_CUSTOM_DRIVER
1110 void backlight_task(void) {
1111 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1112 #if BACKLIGHT_ON_STATE == 0
1114 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1117 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1120 #if BACKLIGHT_ON_STATE == 0
1122 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1125 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1128 backlight_tick = (backlight_tick + 1) % 16;
1132 #ifdef BACKLIGHT_BREATHING
1133 #ifndef BACKLIGHT_CUSTOM_DRIVER
1134 #error "Backlight breathing only available with hardware PWM. Please disable."
1138 #else // pwm through timer
1140 #define TIMER_TOP 0xFFFFU
1142 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1143 static uint16_t cie_lightness(uint16_t v) {
1144 if (v <= 5243) // if below 8% of max
1145 return v / 9; // same as dividing by 900%
1147 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1148 // to get a useful result with integer division, we shift left in the expression above
1149 // and revert what we've done again after squaring.
1151 if (y > 0xFFFFUL) // prevent overflow
1154 return (uint16_t) y;
1158 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1159 static inline void set_pwm(uint16_t val) {
1163 #ifndef BACKLIGHT_CUSTOM_DRIVER
1164 __attribute__ ((weak))
1165 void backlight_set(uint8_t level) {
1166 if (level > BACKLIGHT_LEVELS)
1167 level = BACKLIGHT_LEVELS;
1170 // Turn off PWM control on backlight pin
1171 TCCRxA &= ~(_BV(COMxx1));
1173 // Turn on PWM control of backlight pin
1174 TCCRxA |= _BV(COMxx1);
1176 // Set the brightness
1177 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1180 void backlight_task(void) {}
1181 #endif // BACKLIGHT_CUSTOM_DRIVER
1183 #ifdef BACKLIGHT_BREATHING
1185 #define BREATHING_NO_HALT 0
1186 #define BREATHING_HALT_OFF 1
1187 #define BREATHING_HALT_ON 2
1188 #define BREATHING_STEPS 128
1190 static uint8_t breathing_period = BREATHING_PERIOD;
1191 static uint8_t breathing_halt = BREATHING_NO_HALT;
1192 static uint16_t breathing_counter = 0;
1194 bool is_breathing(void) {
1195 return !!(TIMSK1 & _BV(TOIE1));
1198 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1199 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1200 #define breathing_min() do {breathing_counter = 0;} while (0)
1201 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1203 void breathing_enable(void)
1205 breathing_counter = 0;
1206 breathing_halt = BREATHING_NO_HALT;
1207 breathing_interrupt_enable();
1210 void breathing_pulse(void)
1212 if (get_backlight_level() == 0)
1216 breathing_halt = BREATHING_HALT_ON;
1217 breathing_interrupt_enable();
1220 void breathing_disable(void)
1222 breathing_interrupt_disable();
1223 // Restore backlight level
1224 backlight_set(get_backlight_level());
1227 void breathing_self_disable(void)
1229 if (get_backlight_level() == 0)
1230 breathing_halt = BREATHING_HALT_OFF;
1232 breathing_halt = BREATHING_HALT_ON;
1235 void breathing_toggle(void) {
1237 breathing_disable();
1242 void breathing_period_set(uint8_t value)
1246 breathing_period = value;
1249 void breathing_period_default(void) {
1250 breathing_period_set(BREATHING_PERIOD);
1253 void breathing_period_inc(void)
1255 breathing_period_set(breathing_period+1);
1258 void breathing_period_dec(void)
1260 breathing_period_set(breathing_period-1);
1263 /* To generate breathing curve in python:
1264 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1266 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};
1268 // Use this before the cie_lightness function.
1269 static inline uint16_t scale_backlight(uint16_t v) {
1270 return v / BACKLIGHT_LEVELS * get_backlight_level();
1273 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1274 * about 244 times per second.
1276 ISR(TIMER1_OVF_vect)
1278 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1279 // resetting after one period to prevent ugly reset at overflow.
1280 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1281 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1283 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1284 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1286 breathing_interrupt_disable();
1289 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1292 #endif // BACKLIGHT_BREATHING
1294 __attribute__ ((weak))
1295 void backlight_init_ports(void)
1297 // Setup backlight pin as output and output to on state.
1299 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1300 #if BACKLIGHT_ON_STATE == 0
1302 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1305 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1307 // I could write a wall of text here to explain... but TL;DW
1308 // Go read the ATmega32u4 datasheet.
1309 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1311 // Pin PB7 = OCR1C (Timer 1, Channel C)
1312 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1313 // (i.e. start high, go low when counter matches.)
1314 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1315 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1319 "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 [..]."
1320 "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)."
1322 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1323 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1324 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1328 #ifdef BACKLIGHT_BREATHING
1333 #endif // NO_HARDWARE_PWM
1337 __attribute__ ((weak))
1338 void backlight_init_ports(void) {}
1340 __attribute__ ((weak))
1341 void backlight_set(uint8_t level) {}
1345 #ifdef HD44780_ENABLED
1346 #include "hd44780.h"
1350 // Functions for spitting out values
1353 void send_dword(uint32_t number) { // this might not actually work
1354 uint16_t word = (number >> 16);
1356 send_word(number & 0xFFFFUL);
1359 void send_word(uint16_t number) {
1360 uint8_t byte = number >> 8;
1362 send_byte(number & 0xFF);
1365 void send_byte(uint8_t number) {
1366 uint8_t nibble = number >> 4;
1367 send_nibble(nibble);
1368 send_nibble(number & 0xF);
1371 void send_nibble(uint8_t number) {
1374 register_code(KC_0);
1375 unregister_code(KC_0);
1378 register_code(KC_1 + (number - 1));
1379 unregister_code(KC_1 + (number - 1));
1382 register_code(KC_A + (number - 0xA));
1383 unregister_code(KC_A + (number - 0xA));
1389 __attribute__((weak))
1390 uint16_t hex_to_keycode(uint8_t hex)
1395 } else if (hex < 0xA) {
1396 return KC_1 + (hex - 0x1);
1398 return KC_A + (hex - 0xA);
1402 void api_send_unicode(uint32_t unicode) {
1405 dword_to_bytes(unicode, chunk);
1406 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1410 __attribute__ ((weak))
1411 void led_set_user(uint8_t usb_led) {
1415 __attribute__ ((weak))
1416 void led_set_kb(uint8_t usb_led) {
1417 led_set_user(usb_led);
1420 __attribute__ ((weak))
1421 void led_init_ports(void)
1426 __attribute__ ((weak))
1427 void led_set(uint8_t usb_led)
1432 // // Using PE6 Caps Lock LED
1433 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1443 // PORTE &= ~(1<<6);
1446 led_set_kb(usb_led);
1450 //------------------------------------------------------------------------------
1451 // Override these functions in your keymap file to play different tunes on
1452 // different events such as startup and bootloader jump
1454 __attribute__ ((weak))
1455 void startup_user() {}
1457 __attribute__ ((weak))
1458 void shutdown_user() {}
1460 //------------------------------------------------------------------------------