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"
28 #define TAPPING_TERM 200
31 #ifndef BREATHING_PERIOD
32 #define BREATHING_PERIOD 6
35 #include "backlight.h"
36 extern backlight_config_t backlight_config;
38 #ifdef FAUXCLICKY_ENABLE
39 #include "fauxclicky.h"
47 #include "process_midi.h"
50 #ifdef VELOCIKEY_ENABLE
51 #include "velocikey.h"
64 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
67 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
70 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
72 float goodbye_song[][2] = GOODBYE_SONG;
73 float ag_norm_song[][2] = AG_NORM_SONG;
74 float ag_swap_song[][2] = AG_SWAP_SONG;
75 #ifdef DEFAULT_LAYER_SONGS
76 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
80 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
82 case QK_MODS ... QK_MODS_MAX:
97 if (code < QK_RMODS_MIN) return;
109 static inline void qk_register_weak_mods(uint8_t kc) {
110 add_weak_mods(MOD_BIT(kc));
111 send_keyboard_report();
114 static inline void qk_unregister_weak_mods(uint8_t kc) {
115 del_weak_mods(MOD_BIT(kc));
116 send_keyboard_report();
119 static inline void qk_register_mods(uint8_t kc) {
120 add_weak_mods(MOD_BIT(kc));
121 send_keyboard_report();
124 static inline void qk_unregister_mods(uint8_t kc) {
125 del_weak_mods(MOD_BIT(kc));
126 send_keyboard_report();
129 void register_code16 (uint16_t code) {
130 if (IS_MOD(code) || code == KC_NO) {
131 do_code16 (code, qk_register_mods);
133 do_code16 (code, qk_register_weak_mods);
135 register_code (code);
138 void unregister_code16 (uint16_t code) {
139 unregister_code (code);
140 if (IS_MOD(code) || code == KC_NO) {
141 do_code16 (code, qk_unregister_mods);
143 do_code16 (code, qk_unregister_weak_mods);
147 void tap_code16(uint16_t code) {
148 register_code16(code);
149 #if TAP_CODE_DELAY > 0
150 wait_ms(TAP_CODE_DELAY);
152 unregister_code16(code);
155 __attribute__ ((weak))
156 bool process_action_kb(keyrecord_t *record) {
160 __attribute__ ((weak))
161 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
162 return process_record_user(keycode, record);
165 __attribute__ ((weak))
166 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
170 void reset_keyboard(void) {
172 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
173 process_midi_all_notes_off();
176 #ifndef NO_MUSIC_MODE
177 music_all_notes_off();
179 uint16_t timer_start = timer_read();
180 PLAY_SONG(goodbye_song);
182 while(timer_elapsed(timer_start) < 250)
192 // this is also done later in bootloader.c - not sure if it's neccesary here
193 #ifdef BOOTLOADER_CATERINA
194 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
199 // Shift / paren setup
202 #define LSPO_KEY KC_9
205 #define RSPC_KEY KC_0
209 #define LSPO_MOD KC_LSFT
212 #define RSPC_MOD KC_RSFT
215 // Shift / Enter setup
217 #define SFTENT_KEY KC_ENT
220 static bool shift_interrupted[2] = {0, 0};
221 static uint16_t scs_timer[2] = {0, 0};
223 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
224 * Used to ensure that the correct keycode is released if the key is released.
226 static bool grave_esc_was_shifted = false;
228 /* Convert record into usable keycode via the contained event. */
229 uint16_t get_record_keycode(keyrecord_t *record) {
230 return get_event_keycode(record->event);
234 /* Convert event into usable keycode. Checks the layer cache to ensure that it
235 * retains the correct keycode after a layer change, if the key is still pressed.
237 uint16_t get_event_keycode(keyevent_t event) {
239 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
240 /* TODO: Use store_or_get_action() or a similar function. */
241 if (!disable_action_cache) {
245 layer = layer_switch_get_layer(event.key);
246 update_source_layers_cache(event.key, layer);
248 layer = read_source_layers_cache(event.key);
250 return keymap_key_to_keycode(layer, event.key);
253 return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
256 /* Main keycode processing function. Hands off handling to other functions,
257 * then processes internal Quantum keycodes, then processes ACTIONs.
259 bool process_record_quantum(keyrecord_t *record) {
260 uint16_t keycode = get_record_keycode(record);
262 // This is how you use actions here
263 // if (keycode == KC_LEAD) {
265 // action.code = ACTION_DEFAULT_LAYER_SET(0);
266 // process_action(record, action);
270 #ifdef VELOCIKEY_ENABLE
271 if (velocikey_enabled() && record->event.pressed) { velocikey_accelerate(); }
274 #ifdef TAP_DANCE_ENABLE
275 preprocess_tap_dance(keycode, record);
279 #if defined(KEY_LOCK_ENABLE)
280 // Must run first to be able to mask key_up events.
281 process_key_lock(&keycode, record) &&
283 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
284 process_clicky(keycode, record) &&
285 #endif //AUDIO_CLICKY
287 process_haptic(keycode, record) &&
288 #endif //HAPTIC_ENABLE
289 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYREACTIVE_ENABLED)
290 process_rgb_matrix(keycode, record) &&
292 process_record_kb(keycode, record) &&
293 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
294 process_midi(keycode, record) &&
297 process_audio(keycode, record) &&
300 process_steno(keycode, record) &&
302 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
303 process_music(keycode, record) &&
305 #ifdef TAP_DANCE_ENABLE
306 process_tap_dance(keycode, record) &&
308 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
309 process_unicode_common(keycode, record) &&
312 process_leader(keycode, record) &&
315 process_combo(keycode, record) &&
317 #ifdef PRINTING_ENABLE
318 process_printer(keycode, record) &&
320 #ifdef AUTO_SHIFT_ENABLE
321 process_auto_shift(keycode, record) &&
323 #ifdef TERMINAL_ENABLE
324 process_terminal(keycode, record) &&
330 // Shift / paren setup
334 if (record->event.pressed) {
339 if (record->event.pressed) {
341 print("DEBUG: enabled.\n");
345 if (record->event.pressed) {
349 #ifdef FAUXCLICKY_ENABLE
351 if (record->event.pressed) {
356 if (record->event.pressed) {
361 if (record->event.pressed) {
366 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
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) {
377 case RGB_MODE_FORWARD:
378 if (record->event.pressed) {
379 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
381 rgblight_step_reverse();
388 case RGB_MODE_REVERSE:
389 if (record->event.pressed) {
390 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
395 rgblight_step_reverse();
400 // Split keyboards need to trigger on key-up for edge-case issue
401 #ifndef SPLIT_KEYBOARD
402 if (record->event.pressed) {
404 if (!record->event.pressed) {
406 rgblight_increase_hue();
410 // Split keyboards need to trigger on key-up for edge-case issue
411 #ifndef SPLIT_KEYBOARD
412 if (record->event.pressed) {
414 if (!record->event.pressed) {
416 rgblight_decrease_hue();
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_sat();
430 // Split keyboards need to trigger on key-up for edge-case issue
431 #ifndef SPLIT_KEYBOARD
432 if (record->event.pressed) {
434 if (!record->event.pressed) {
436 rgblight_decrease_sat();
440 // Split keyboards need to trigger on key-up for edge-case issue
441 #ifndef SPLIT_KEYBOARD
442 if (record->event.pressed) {
444 if (!record->event.pressed) {
446 rgblight_increase_val();
450 // Split keyboards need to trigger on key-up for edge-case issue
451 #ifndef SPLIT_KEYBOARD
452 if (record->event.pressed) {
454 if (!record->event.pressed) {
456 rgblight_decrease_val();
460 if (record->event.pressed) {
461 rgblight_increase_speed();
465 if (record->event.pressed) {
466 rgblight_decrease_speed();
470 if (record->event.pressed) {
471 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
474 case RGB_MODE_BREATHE:
475 #ifdef RGBLIGHT_EFFECT_BREATHING
476 if (record->event.pressed) {
477 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
478 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
481 rgblight_mode(RGBLIGHT_MODE_BREATHING);
486 case RGB_MODE_RAINBOW:
487 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
488 if (record->event.pressed) {
489 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
490 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
493 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
499 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
500 if (record->event.pressed) {
501 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
502 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
505 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
511 #ifdef RGBLIGHT_EFFECT_SNAKE
512 if (record->event.pressed) {
513 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
514 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
517 rgblight_mode(RGBLIGHT_MODE_SNAKE);
522 case RGB_MODE_KNIGHT:
523 #ifdef RGBLIGHT_EFFECT_KNIGHT
524 if (record->event.pressed) {
525 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
526 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
529 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
535 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
536 if (record->event.pressed) {
537 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
541 case RGB_MODE_GRADIENT:
542 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
543 if (record->event.pressed) {
544 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
545 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
548 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
553 case RGB_MODE_RGBTEST:
554 #ifdef RGBLIGHT_EFFECT_RGB_TEST
555 if (record->event.pressed) {
556 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
560 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
561 #ifdef VELOCIKEY_ENABLE
563 if (record->event.pressed) {
570 if (record->event.pressed) {
571 set_output(OUTPUT_AUTO);
575 if (record->event.pressed) {
576 set_output(OUTPUT_USB);
579 #ifdef BLUETOOTH_ENABLE
581 if (record->event.pressed) {
582 set_output(OUTPUT_BLUETOOTH);
587 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
588 if (record->event.pressed) {
589 // MAGIC actions (BOOTMAGIC without the boot)
590 if (!eeconfig_is_enabled()) {
594 keymap_config.raw = eeconfig_read_keymap();
597 case MAGIC_SWAP_CONTROL_CAPSLOCK:
598 keymap_config.swap_control_capslock = true;
600 case MAGIC_CAPSLOCK_TO_CONTROL:
601 keymap_config.capslock_to_control = true;
603 case MAGIC_SWAP_LALT_LGUI:
604 keymap_config.swap_lalt_lgui = true;
606 case MAGIC_SWAP_RALT_RGUI:
607 keymap_config.swap_ralt_rgui = true;
610 keymap_config.no_gui = true;
612 case MAGIC_SWAP_GRAVE_ESC:
613 keymap_config.swap_grave_esc = true;
615 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
616 keymap_config.swap_backslash_backspace = true;
618 case MAGIC_HOST_NKRO:
619 keymap_config.nkro = true;
621 case MAGIC_SWAP_ALT_GUI:
622 keymap_config.swap_lalt_lgui = true;
623 keymap_config.swap_ralt_rgui = true;
625 PLAY_SONG(ag_swap_song);
628 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
629 keymap_config.swap_control_capslock = false;
631 case MAGIC_UNCAPSLOCK_TO_CONTROL:
632 keymap_config.capslock_to_control = false;
634 case MAGIC_UNSWAP_LALT_LGUI:
635 keymap_config.swap_lalt_lgui = false;
637 case MAGIC_UNSWAP_RALT_RGUI:
638 keymap_config.swap_ralt_rgui = false;
641 keymap_config.no_gui = false;
643 case MAGIC_UNSWAP_GRAVE_ESC:
644 keymap_config.swap_grave_esc = false;
646 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
647 keymap_config.swap_backslash_backspace = false;
649 case MAGIC_UNHOST_NKRO:
650 keymap_config.nkro = false;
652 case MAGIC_UNSWAP_ALT_GUI:
653 keymap_config.swap_lalt_lgui = false;
654 keymap_config.swap_ralt_rgui = false;
656 PLAY_SONG(ag_norm_song);
659 case MAGIC_TOGGLE_ALT_GUI:
660 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
661 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
663 if (keymap_config.swap_ralt_rgui) {
664 PLAY_SONG(ag_swap_song);
666 PLAY_SONG(ag_norm_song);
670 case MAGIC_TOGGLE_NKRO:
671 keymap_config.nkro = !keymap_config.nkro;
676 eeconfig_update_keymap(keymap_config.raw);
677 clear_keyboard(); // clear to prevent stuck keys
683 if (record->event.pressed) {
684 shift_interrupted[0] = false;
685 scs_timer[0] = timer_read ();
686 register_mods(MOD_BIT(KC_LSFT));
689 #ifdef DISABLE_SPACE_CADET_ROLLOVER
690 if (get_mods() & MOD_BIT(RSPC_MOD)) {
691 shift_interrupted[0] = true;
692 shift_interrupted[1] = true;
695 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
696 #ifdef DISABLE_SPACE_CADET_MODIFIER
697 unregister_mods(MOD_BIT(KC_LSFT));
699 if( LSPO_MOD != KC_LSFT ){
700 unregister_mods(MOD_BIT(KC_LSFT));
701 register_mods(MOD_BIT(LSPO_MOD));
704 register_code(LSPO_KEY);
705 unregister_code(LSPO_KEY);
706 #ifndef DISABLE_SPACE_CADET_MODIFIER
707 if( LSPO_MOD != KC_LSFT ){
708 unregister_mods(MOD_BIT(LSPO_MOD));
712 unregister_mods(MOD_BIT(KC_LSFT));
718 if (record->event.pressed) {
719 shift_interrupted[1] = false;
720 scs_timer[1] = timer_read ();
721 register_mods(MOD_BIT(KC_RSFT));
724 #ifdef DISABLE_SPACE_CADET_ROLLOVER
725 if (get_mods() & MOD_BIT(LSPO_MOD)) {
726 shift_interrupted[0] = true;
727 shift_interrupted[1] = true;
730 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
731 #ifdef DISABLE_SPACE_CADET_MODIFIER
732 unregister_mods(MOD_BIT(KC_RSFT));
734 if( RSPC_MOD != KC_RSFT ){
735 unregister_mods(MOD_BIT(KC_RSFT));
736 register_mods(MOD_BIT(RSPC_MOD));
739 register_code(RSPC_KEY);
740 unregister_code(RSPC_KEY);
741 #ifndef DISABLE_SPACE_CADET_MODIFIER
742 if ( RSPC_MOD != KC_RSFT ){
743 unregister_mods(MOD_BIT(RSPC_MOD));
747 unregister_mods(MOD_BIT(KC_RSFT));
753 if (record->event.pressed) {
754 shift_interrupted[1] = false;
755 scs_timer[1] = timer_read ();
756 register_mods(MOD_BIT(KC_RSFT));
758 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
759 unregister_mods(MOD_BIT(KC_RSFT));
760 register_code(SFTENT_KEY);
761 unregister_code(SFTENT_KEY);
764 unregister_mods(MOD_BIT(KC_RSFT));
770 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
771 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
773 #ifdef GRAVE_ESC_ALT_OVERRIDE
774 // if ALT is pressed, ESC is always sent
775 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
776 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
781 #ifdef GRAVE_ESC_CTRL_OVERRIDE
782 // if CTRL is pressed, ESC is always sent
783 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
784 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
789 #ifdef GRAVE_ESC_GUI_OVERRIDE
790 // if GUI is pressed, ESC is always sent
791 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
796 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
797 // if SHIFT is pressed, ESC is always sent
798 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
803 if (record->event.pressed) {
804 grave_esc_was_shifted = shifted;
805 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
808 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
811 send_keyboard_report();
815 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
817 if (record->event.pressed)
824 shift_interrupted[0] = true;
825 shift_interrupted[1] = true;
830 return process_action_kb(record);
833 __attribute__ ((weak))
834 const bool ascii_to_shift_lut[0x80] PROGMEM = {
835 0, 0, 0, 0, 0, 0, 0, 0,
836 0, 0, 0, 0, 0, 0, 0, 0,
837 0, 0, 0, 0, 0, 0, 0, 0,
838 0, 0, 0, 0, 0, 0, 0, 0,
839 0, 1, 1, 1, 1, 1, 1, 0,
840 1, 1, 1, 1, 0, 0, 0, 0,
841 0, 0, 0, 0, 0, 0, 0, 0,
842 0, 0, 1, 0, 1, 0, 1, 1,
843 1, 1, 1, 1, 1, 1, 1, 1,
844 1, 1, 1, 1, 1, 1, 1, 1,
845 1, 1, 1, 1, 1, 1, 1, 1,
846 1, 1, 1, 0, 0, 0, 1, 1,
847 0, 0, 0, 0, 0, 0, 0, 0,
848 0, 0, 0, 0, 0, 0, 0, 0,
849 0, 0, 0, 0, 0, 0, 0, 0,
850 0, 0, 0, 1, 1, 1, 1, 0
853 __attribute__ ((weak))
854 const bool ascii_to_alt_lut[0x80] PROGMEM = {
855 0, 0, 0, 0, 0, 0, 0, 0,
856 0, 0, 0, 0, 0, 0, 0, 0,
857 0, 0, 0, 0, 0, 0, 0, 0,
858 0, 0, 0, 0, 0, 0, 0, 0,
859 0, 0, 0, 0, 0, 0, 0, 0,
860 0, 0, 0, 0, 0, 0, 0, 0,
861 0, 0, 0, 0, 0, 0, 0, 0,
862 0, 0, 0, 0, 0, 0, 0, 0,
863 0, 0, 0, 0, 0, 0, 0, 0,
864 0, 0, 0, 0, 0, 0, 0, 0,
865 0, 0, 0, 0, 0, 0, 0, 0,
866 0, 0, 0, 0, 0, 0, 0, 0,
867 0, 0, 0, 0, 0, 0, 0, 0,
868 0, 0, 0, 0, 0, 0, 0, 0,
869 0, 0, 0, 0, 0, 0, 0, 0,
870 0, 0, 0, 0, 0, 0, 0, 0
873 __attribute__ ((weak))
874 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
875 0, 0, 0, 0, 0, 0, 0, 0,
876 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
877 0, 0, 0, 0, 0, 0, 0, 0,
878 0, 0, 0, KC_ESC, 0, 0, 0, 0,
879 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
880 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
881 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
882 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
883 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
884 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
885 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
886 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
887 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
888 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
889 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
890 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
893 void send_string(const char *str) {
894 send_string_with_delay(str, 0);
897 void send_string_P(const char *str) {
898 send_string_with_delay_P(str, 0);
901 void send_string_with_delay(const char *str, uint8_t interval) {
903 char ascii_code = *str;
904 if (!ascii_code) break;
905 if (ascii_code == SS_TAP_CODE) {
907 uint8_t keycode = *(++str);
908 register_code(keycode);
909 unregister_code(keycode);
910 } else if (ascii_code == SS_DOWN_CODE) {
912 uint8_t keycode = *(++str);
913 register_code(keycode);
914 } else if (ascii_code == SS_UP_CODE) {
916 uint8_t keycode = *(++str);
917 unregister_code(keycode);
919 send_char(ascii_code);
923 { uint8_t ms = interval; while (ms--) wait_ms(1); }
927 void send_string_with_delay_P(const char *str, uint8_t interval) {
929 char ascii_code = pgm_read_byte(str);
930 if (!ascii_code) break;
931 if (ascii_code == SS_TAP_CODE) {
933 uint8_t keycode = pgm_read_byte(++str);
934 register_code(keycode);
935 unregister_code(keycode);
936 } else if (ascii_code == SS_DOWN_CODE) {
938 uint8_t keycode = pgm_read_byte(++str);
939 register_code(keycode);
940 } else if (ascii_code == SS_UP_CODE) {
942 uint8_t keycode = pgm_read_byte(++str);
943 unregister_code(keycode);
945 send_char(ascii_code);
949 { uint8_t ms = interval; while (ms--) wait_ms(1); }
953 void send_char(char ascii_code) {
958 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
959 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) { is_shifted = true; } else { is_shifted = false; }
960 if (pgm_read_byte(&ascii_to_alt_lut[(uint8_t)ascii_code])) { is_alted = true; } else { is_alted = false; }
962 if (is_shifted) { register_code(KC_LSFT); }
963 if (is_alted) { register_code(KC_RALT); }
965 register_code(keycode);
966 unregister_code(keycode);
968 if (is_alted) { unregister_code(KC_RALT); }
969 if (is_shifted) { unregister_code(KC_LSFT); }
972 void set_single_persistent_default_layer(uint8_t default_layer) {
973 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
974 PLAY_SONG(default_layer_songs[default_layer]);
976 eeconfig_update_default_layer(1U<<default_layer);
977 default_layer_set(1U<<default_layer);
980 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
981 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
982 uint32_t mask3 = 1UL << layer3;
983 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
986 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
987 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
990 void tap_random_base64(void) {
991 #if defined(__AVR_ATmega32U4__)
992 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
994 uint8_t key = rand() % 64;
998 register_code(KC_LSFT);
999 register_code(key + KC_A);
1000 unregister_code(key + KC_A);
1001 unregister_code(KC_LSFT);
1004 register_code(key - 26 + KC_A);
1005 unregister_code(key - 26 + KC_A);
1008 register_code(KC_0);
1009 unregister_code(KC_0);
1012 register_code(key - 53 + KC_1);
1013 unregister_code(key - 53 + KC_1);
1016 register_code(KC_LSFT);
1017 register_code(KC_EQL);
1018 unregister_code(KC_EQL);
1019 unregister_code(KC_LSFT);
1022 register_code(KC_SLSH);
1023 unregister_code(KC_SLSH);
1028 __attribute__((weak))
1029 void bootmagic_lite(void) {
1030 // The lite version of TMK's bootmagic based on Wilba.
1031 // 100% less potential for accidentally making the
1032 // keyboard do stupid things.
1034 // We need multiple scans because debouncing can't be turned off.
1036 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
1037 wait_ms(DEBOUNCING_DELAY * 2);
1038 #elif defined(DEBOUNCE) && DEBOUNCE > 0
1039 wait_ms(DEBOUNCE * 2);
1045 // If the Esc and space bar are held down on power up,
1046 // reset the EEPROM valid state and jump to bootloader.
1047 // Assumes Esc is at [0,0].
1048 // This isn't very generalized, but we need something that doesn't
1049 // rely on user's keymaps in firmware or EEPROM.
1050 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
1052 // Jump to bootloader.
1057 void matrix_init_quantum() {
1058 #ifdef BOOTMAGIC_LITE
1061 if (!eeconfig_is_enabled()) {
1064 #ifdef BACKLIGHT_ENABLE
1065 #ifdef LED_MATRIX_ENABLE
1068 backlight_init_ports();
1074 #ifdef RGB_MATRIX_ENABLE
1077 #ifdef ENCODER_ENABLE
1080 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1081 unicode_input_mode_init();
1083 #ifdef HAPTIC_ENABLE
1089 void matrix_scan_quantum() {
1090 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1091 matrix_scan_music();
1094 #ifdef TAP_DANCE_ENABLE
1095 matrix_scan_tap_dance();
1099 matrix_scan_combo();
1102 #if defined(BACKLIGHT_ENABLE)
1103 #if defined(LED_MATRIX_ENABLE)
1105 #elif defined(BACKLIGHT_PIN)
1110 #ifdef RGB_MATRIX_ENABLE
1114 #ifdef ENCODER_ENABLE
1118 #ifdef HAPTIC_ENABLE
1124 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1126 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1128 // depending on the pin, we use a different output compare unit
1129 #if BACKLIGHT_PIN == B7
1130 # define TCCRxA TCCR1A
1131 # define TCCRxB TCCR1B
1132 # define COMxx1 COM1C1
1133 # define OCRxx OCR1C
1135 #elif BACKLIGHT_PIN == B6
1136 # define TCCRxA TCCR1A
1137 # define TCCRxB TCCR1B
1138 # define COMxx1 COM1B1
1139 # define OCRxx OCR1B
1141 #elif BACKLIGHT_PIN == B5
1142 # define TCCRxA TCCR1A
1143 # define TCCRxB TCCR1B
1144 # define COMxx1 COM1A1
1145 # define OCRxx OCR1A
1147 #elif BACKLIGHT_PIN == C6
1148 # define TCCRxA TCCR3A
1149 # define TCCRxB TCCR3B
1150 # define COMxx1 COM1A1
1151 # define OCRxx OCR3A
1153 #elif defined(__AVR_ATmega32A__) && BACKLIGHT_PIN == D4
1154 # define TCCRxA TCCR1A
1155 # define TCCRxB TCCR1B
1156 # define COMxx1 COM1B1
1157 # define OCRxx OCR1B
1159 # define TIMSK1 TIMSK
1161 # define NO_HARDWARE_PWM
1164 #ifndef BACKLIGHT_ON_STATE
1165 #define BACKLIGHT_ON_STATE 0
1168 #ifdef NO_HARDWARE_PWM // pwm through software
1170 __attribute__ ((weak))
1171 void backlight_init_ports(void)
1173 // Setup backlight pin as output and output to on state.
1175 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1176 #if BACKLIGHT_ON_STATE == 0
1178 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1181 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1185 __attribute__ ((weak))
1186 void backlight_set(uint8_t level) {}
1188 uint8_t backlight_tick = 0;
1190 #ifndef BACKLIGHT_CUSTOM_DRIVER
1191 void backlight_task(void) {
1192 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1193 #if BACKLIGHT_ON_STATE == 0
1195 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1198 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1201 #if BACKLIGHT_ON_STATE == 0
1203 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1206 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1209 backlight_tick = (backlight_tick + 1) % 16;
1213 #ifdef BACKLIGHT_BREATHING
1214 #ifndef BACKLIGHT_CUSTOM_DRIVER
1215 #error "Backlight breathing only available with hardware PWM. Please disable."
1219 #else // pwm through timer
1221 #define TIMER_TOP 0xFFFFU
1223 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1224 static uint16_t cie_lightness(uint16_t v) {
1225 if (v <= 5243) // if below 8% of max
1226 return v / 9; // same as dividing by 900%
1228 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1229 // to get a useful result with integer division, we shift left in the expression above
1230 // and revert what we've done again after squaring.
1232 if (y > 0xFFFFUL) // prevent overflow
1235 return (uint16_t) y;
1239 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1240 static inline void set_pwm(uint16_t val) {
1244 #ifndef BACKLIGHT_CUSTOM_DRIVER
1245 __attribute__ ((weak))
1246 void backlight_set(uint8_t level) {
1247 if (level > BACKLIGHT_LEVELS)
1248 level = BACKLIGHT_LEVELS;
1251 // Turn off PWM control on backlight pin
1252 TCCRxA &= ~(_BV(COMxx1));
1254 // Turn on PWM control of backlight pin
1255 TCCRxA |= _BV(COMxx1);
1257 // Set the brightness
1258 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1261 void backlight_task(void) {}
1262 #endif // BACKLIGHT_CUSTOM_DRIVER
1264 #ifdef BACKLIGHT_BREATHING
1266 #define BREATHING_NO_HALT 0
1267 #define BREATHING_HALT_OFF 1
1268 #define BREATHING_HALT_ON 2
1269 #define BREATHING_STEPS 128
1271 static uint8_t breathing_period = BREATHING_PERIOD;
1272 static uint8_t breathing_halt = BREATHING_NO_HALT;
1273 static uint16_t breathing_counter = 0;
1275 bool is_breathing(void) {
1276 return !!(TIMSK1 & _BV(TOIE1));
1279 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1280 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1281 #define breathing_min() do {breathing_counter = 0;} while (0)
1282 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1284 void breathing_enable(void)
1286 breathing_counter = 0;
1287 breathing_halt = BREATHING_NO_HALT;
1288 breathing_interrupt_enable();
1291 void breathing_pulse(void)
1293 if (get_backlight_level() == 0)
1297 breathing_halt = BREATHING_HALT_ON;
1298 breathing_interrupt_enable();
1301 void breathing_disable(void)
1303 breathing_interrupt_disable();
1304 // Restore backlight level
1305 backlight_set(get_backlight_level());
1308 void breathing_self_disable(void)
1310 if (get_backlight_level() == 0)
1311 breathing_halt = BREATHING_HALT_OFF;
1313 breathing_halt = BREATHING_HALT_ON;
1316 void breathing_toggle(void) {
1318 breathing_disable();
1323 void breathing_period_set(uint8_t value)
1327 breathing_period = value;
1330 void breathing_period_default(void) {
1331 breathing_period_set(BREATHING_PERIOD);
1334 void breathing_period_inc(void)
1336 breathing_period_set(breathing_period+1);
1339 void breathing_period_dec(void)
1341 breathing_period_set(breathing_period-1);
1344 /* To generate breathing curve in python:
1345 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1347 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};
1349 // Use this before the cie_lightness function.
1350 static inline uint16_t scale_backlight(uint16_t v) {
1351 return v / BACKLIGHT_LEVELS * get_backlight_level();
1354 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1355 * about 244 times per second.
1357 ISR(TIMER1_OVF_vect)
1359 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1360 // resetting after one period to prevent ugly reset at overflow.
1361 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1362 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1364 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1365 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1367 breathing_interrupt_disable();
1370 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1373 #endif // BACKLIGHT_BREATHING
1375 __attribute__ ((weak))
1376 void backlight_init_ports(void)
1378 // Setup backlight pin as output and output to on state.
1380 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1381 #if BACKLIGHT_ON_STATE == 0
1383 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1386 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1388 // I could write a wall of text here to explain... but TL;DW
1389 // Go read the ATmega32u4 datasheet.
1390 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1392 // Pin PB7 = OCR1C (Timer 1, Channel C)
1393 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1394 // (i.e. start high, go low when counter matches.)
1395 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1396 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1400 "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 [..]."
1401 "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)."
1403 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1404 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1405 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1409 #ifdef BACKLIGHT_BREATHING
1414 #endif // NO_HARDWARE_PWM
1418 __attribute__ ((weak))
1419 void backlight_init_ports(void) {}
1421 __attribute__ ((weak))
1422 void backlight_set(uint8_t level) {}
1426 #ifdef HD44780_ENABLED
1427 #include "hd44780.h"
1431 // Functions for spitting out values
1434 void send_dword(uint32_t number) { // this might not actually work
1435 uint16_t word = (number >> 16);
1437 send_word(number & 0xFFFFUL);
1440 void send_word(uint16_t number) {
1441 uint8_t byte = number >> 8;
1443 send_byte(number & 0xFF);
1446 void send_byte(uint8_t number) {
1447 uint8_t nibble = number >> 4;
1448 send_nibble(nibble);
1449 send_nibble(number & 0xF);
1452 void send_nibble(uint8_t number) {
1455 register_code(KC_0);
1456 unregister_code(KC_0);
1459 register_code(KC_1 + (number - 1));
1460 unregister_code(KC_1 + (number - 1));
1463 register_code(KC_A + (number - 0xA));
1464 unregister_code(KC_A + (number - 0xA));
1470 __attribute__((weak))
1471 uint16_t hex_to_keycode(uint8_t hex)
1476 } else if (hex < 0xA) {
1477 return KC_1 + (hex - 0x1);
1479 return KC_A + (hex - 0xA);
1483 void api_send_unicode(uint32_t unicode) {
1486 dword_to_bytes(unicode, chunk);
1487 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1491 __attribute__ ((weak))
1492 void led_set_user(uint8_t usb_led) {
1496 __attribute__ ((weak))
1497 void led_set_kb(uint8_t usb_led) {
1498 led_set_user(usb_led);
1501 __attribute__ ((weak))
1502 void led_init_ports(void)
1507 __attribute__ ((weak))
1508 void led_set(uint8_t usb_led)
1513 // // Using PE6 Caps Lock LED
1514 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1524 // PORTE &= ~(1<<6);
1527 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1528 // Use backlight as Caps Lock indicator
1529 uint8_t bl_toggle_lvl = 0;
1531 if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1532 // Turning Caps Lock ON and backlight is disabled in config
1533 // Toggling backlight to the brightest level
1534 bl_toggle_lvl = BACKLIGHT_LEVELS;
1535 } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1536 // Turning Caps Lock OFF and backlight is enabled in config
1537 // Toggling backlight and restoring config level
1538 bl_toggle_lvl = backlight_config.level;
1541 // Set level without modify backlight_config to keep ability to restore state
1542 backlight_set(bl_toggle_lvl);
1545 led_set_kb(usb_led);
1549 //------------------------------------------------------------------------------
1550 // Override these functions in your keymap file to play different tunes on
1551 // different events such as startup and bootloader jump
1553 __attribute__ ((weak))
1554 void startup_user() {}
1556 __attribute__ ((weak))
1557 void shutdown_user() {}
1559 //------------------------------------------------------------------------------