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 bool process_record_quantum(keyrecord_t *record) {
230 /* This gets the keycode from the key pressed */
231 keypos_t key = record->event.key;
234 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
235 /* TODO: Use store_or_get_action() or a similar function. */
236 if (!disable_action_cache) {
239 if (record->event.pressed) {
240 layer = layer_switch_get_layer(key);
241 update_source_layers_cache(key, layer);
243 layer = read_source_layers_cache(key);
245 keycode = keymap_key_to_keycode(layer, key);
248 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
250 // This is how you use actions here
251 // if (keycode == KC_LEAD) {
253 // action.code = ACTION_DEFAULT_LAYER_SET(0);
254 // process_action(record, action);
258 #ifdef VELOCIKEY_ENABLE
259 if (velocikey_enabled() && record->event.pressed) { velocikey_accelerate(); }
262 #ifdef TAP_DANCE_ENABLE
263 preprocess_tap_dance(keycode, record);
267 #if defined(KEY_LOCK_ENABLE)
268 // Must run first to be able to mask key_up events.
269 process_key_lock(&keycode, record) &&
271 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
272 process_clicky(keycode, record) &&
273 #endif //AUDIO_CLICKY
275 process_haptic(keycode, record) &&
276 #endif //HAPTIC_ENABLE
277 process_record_kb(keycode, record) &&
278 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
279 process_rgb_matrix(keycode, record) &&
281 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
282 process_midi(keycode, record) &&
285 process_audio(keycode, record) &&
288 process_steno(keycode, record) &&
290 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
291 process_music(keycode, record) &&
293 #ifdef TAP_DANCE_ENABLE
294 process_tap_dance(keycode, record) &&
296 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
297 process_unicode_common(keycode, record) &&
300 process_leader(keycode, record) &&
303 process_combo(keycode, record) &&
305 #ifdef PRINTING_ENABLE
306 process_printer(keycode, record) &&
308 #ifdef AUTO_SHIFT_ENABLE
309 process_auto_shift(keycode, record) &&
311 #ifdef TERMINAL_ENABLE
312 process_terminal(keycode, record) &&
318 // Shift / paren setup
322 if (record->event.pressed) {
327 if (record->event.pressed) {
329 print("DEBUG: enabled.\n");
333 if (record->event.pressed) {
337 #ifdef FAUXCLICKY_ENABLE
339 if (record->event.pressed) {
344 if (record->event.pressed) {
349 if (record->event.pressed) {
354 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
356 // Split keyboards need to trigger on key-up for edge-case issue
357 #ifndef SPLIT_KEYBOARD
358 if (record->event.pressed) {
360 if (!record->event.pressed) {
365 case RGB_MODE_FORWARD:
366 if (record->event.pressed) {
367 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
369 rgblight_step_reverse();
376 case RGB_MODE_REVERSE:
377 if (record->event.pressed) {
378 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
383 rgblight_step_reverse();
388 // Split keyboards need to trigger on key-up for edge-case issue
389 #ifndef SPLIT_KEYBOARD
390 if (record->event.pressed) {
392 if (!record->event.pressed) {
394 rgblight_increase_hue();
398 // Split keyboards need to trigger on key-up for edge-case issue
399 #ifndef SPLIT_KEYBOARD
400 if (record->event.pressed) {
402 if (!record->event.pressed) {
404 rgblight_decrease_hue();
408 // Split keyboards need to trigger on key-up for edge-case issue
409 #ifndef SPLIT_KEYBOARD
410 if (record->event.pressed) {
412 if (!record->event.pressed) {
414 rgblight_increase_sat();
418 // Split keyboards need to trigger on key-up for edge-case issue
419 #ifndef SPLIT_KEYBOARD
420 if (record->event.pressed) {
422 if (!record->event.pressed) {
424 rgblight_decrease_sat();
428 // Split keyboards need to trigger on key-up for edge-case issue
429 #ifndef SPLIT_KEYBOARD
430 if (record->event.pressed) {
432 if (!record->event.pressed) {
434 rgblight_increase_val();
438 // Split keyboards need to trigger on key-up for edge-case issue
439 #ifndef SPLIT_KEYBOARD
440 if (record->event.pressed) {
442 if (!record->event.pressed) {
444 rgblight_decrease_val();
448 if (record->event.pressed) {
449 rgblight_increase_speed();
453 if (record->event.pressed) {
454 rgblight_decrease_speed();
458 if (record->event.pressed) {
459 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
462 case RGB_MODE_BREATHE:
463 #ifdef RGBLIGHT_EFFECT_BREATHING
464 if (record->event.pressed) {
465 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
466 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
469 rgblight_mode(RGBLIGHT_MODE_BREATHING);
474 case RGB_MODE_RAINBOW:
475 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
476 if (record->event.pressed) {
477 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
478 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
481 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
487 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
488 if (record->event.pressed) {
489 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
490 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
493 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
499 #ifdef RGBLIGHT_EFFECT_SNAKE
500 if (record->event.pressed) {
501 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
502 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
505 rgblight_mode(RGBLIGHT_MODE_SNAKE);
510 case RGB_MODE_KNIGHT:
511 #ifdef RGBLIGHT_EFFECT_KNIGHT
512 if (record->event.pressed) {
513 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
514 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
517 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
523 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
524 if (record->event.pressed) {
525 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
529 case RGB_MODE_GRADIENT:
530 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
531 if (record->event.pressed) {
532 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
533 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
536 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
541 case RGB_MODE_RGBTEST:
542 #ifdef RGBLIGHT_EFFECT_RGB_TEST
543 if (record->event.pressed) {
544 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
548 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
549 #ifdef VELOCIKEY_ENABLE
551 if (record->event.pressed) {
558 if (record->event.pressed) {
559 set_output(OUTPUT_AUTO);
563 if (record->event.pressed) {
564 set_output(OUTPUT_USB);
567 #ifdef BLUETOOTH_ENABLE
569 if (record->event.pressed) {
570 set_output(OUTPUT_BLUETOOTH);
575 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
576 if (record->event.pressed) {
577 // MAGIC actions (BOOTMAGIC without the boot)
578 if (!eeconfig_is_enabled()) {
582 keymap_config.raw = eeconfig_read_keymap();
585 case MAGIC_SWAP_CONTROL_CAPSLOCK:
586 keymap_config.swap_control_capslock = true;
588 case MAGIC_CAPSLOCK_TO_CONTROL:
589 keymap_config.capslock_to_control = true;
591 case MAGIC_SWAP_LALT_LGUI:
592 keymap_config.swap_lalt_lgui = true;
594 case MAGIC_SWAP_RALT_RGUI:
595 keymap_config.swap_ralt_rgui = true;
598 keymap_config.no_gui = true;
600 case MAGIC_SWAP_GRAVE_ESC:
601 keymap_config.swap_grave_esc = true;
603 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
604 keymap_config.swap_backslash_backspace = true;
606 case MAGIC_HOST_NKRO:
607 keymap_config.nkro = true;
609 case MAGIC_SWAP_ALT_GUI:
610 keymap_config.swap_lalt_lgui = true;
611 keymap_config.swap_ralt_rgui = true;
613 PLAY_SONG(ag_swap_song);
616 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
617 keymap_config.swap_control_capslock = false;
619 case MAGIC_UNCAPSLOCK_TO_CONTROL:
620 keymap_config.capslock_to_control = false;
622 case MAGIC_UNSWAP_LALT_LGUI:
623 keymap_config.swap_lalt_lgui = false;
625 case MAGIC_UNSWAP_RALT_RGUI:
626 keymap_config.swap_ralt_rgui = false;
629 keymap_config.no_gui = false;
631 case MAGIC_UNSWAP_GRAVE_ESC:
632 keymap_config.swap_grave_esc = false;
634 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
635 keymap_config.swap_backslash_backspace = false;
637 case MAGIC_UNHOST_NKRO:
638 keymap_config.nkro = false;
640 case MAGIC_UNSWAP_ALT_GUI:
641 keymap_config.swap_lalt_lgui = false;
642 keymap_config.swap_ralt_rgui = false;
644 PLAY_SONG(ag_norm_song);
647 case MAGIC_TOGGLE_ALT_GUI:
648 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
649 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
651 if (keymap_config.swap_ralt_rgui) {
652 PLAY_SONG(ag_swap_song);
654 PLAY_SONG(ag_norm_song);
658 case MAGIC_TOGGLE_NKRO:
659 keymap_config.nkro = !keymap_config.nkro;
664 eeconfig_update_keymap(keymap_config.raw);
665 clear_keyboard(); // clear to prevent stuck keys
671 if (record->event.pressed) {
672 shift_interrupted[0] = false;
673 scs_timer[0] = timer_read ();
674 register_mods(MOD_BIT(KC_LSFT));
677 #ifdef DISABLE_SPACE_CADET_ROLLOVER
678 if (get_mods() & MOD_BIT(RSPC_MOD)) {
679 shift_interrupted[0] = true;
680 shift_interrupted[1] = true;
683 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
684 #ifdef DISABLE_SPACE_CADET_MODIFIER
685 unregister_mods(MOD_BIT(KC_LSFT));
687 if( LSPO_MOD != KC_LSFT ){
688 unregister_mods(MOD_BIT(KC_LSFT));
689 register_mods(MOD_BIT(LSPO_MOD));
692 register_code(LSPO_KEY);
693 unregister_code(LSPO_KEY);
694 #ifndef DISABLE_SPACE_CADET_MODIFIER
695 if( LSPO_MOD != KC_LSFT ){
696 unregister_mods(MOD_BIT(LSPO_MOD));
700 unregister_mods(MOD_BIT(KC_LSFT));
706 if (record->event.pressed) {
707 shift_interrupted[1] = false;
708 scs_timer[1] = timer_read ();
709 register_mods(MOD_BIT(KC_RSFT));
712 #ifdef DISABLE_SPACE_CADET_ROLLOVER
713 if (get_mods() & MOD_BIT(LSPO_MOD)) {
714 shift_interrupted[0] = true;
715 shift_interrupted[1] = true;
718 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
719 #ifdef DISABLE_SPACE_CADET_MODIFIER
720 unregister_mods(MOD_BIT(KC_RSFT));
722 if( RSPC_MOD != KC_RSFT ){
723 unregister_mods(MOD_BIT(KC_RSFT));
724 register_mods(MOD_BIT(RSPC_MOD));
727 register_code(RSPC_KEY);
728 unregister_code(RSPC_KEY);
729 #ifndef DISABLE_SPACE_CADET_MODIFIER
730 if ( RSPC_MOD != KC_RSFT ){
731 unregister_mods(MOD_BIT(RSPC_MOD));
735 unregister_mods(MOD_BIT(KC_RSFT));
741 if (record->event.pressed) {
742 shift_interrupted[1] = false;
743 scs_timer[1] = timer_read ();
744 register_mods(MOD_BIT(KC_RSFT));
746 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
747 unregister_mods(MOD_BIT(KC_RSFT));
748 register_code(SFTENT_KEY);
749 unregister_code(SFTENT_KEY);
752 unregister_mods(MOD_BIT(KC_RSFT));
758 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
759 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
761 #ifdef GRAVE_ESC_ALT_OVERRIDE
762 // if ALT is pressed, ESC is always sent
763 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
764 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
769 #ifdef GRAVE_ESC_CTRL_OVERRIDE
770 // if CTRL is pressed, ESC is always sent
771 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
772 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
777 #ifdef GRAVE_ESC_GUI_OVERRIDE
778 // if GUI is pressed, ESC is always sent
779 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
784 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
785 // if SHIFT is pressed, ESC is always sent
786 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
791 if (record->event.pressed) {
792 grave_esc_was_shifted = shifted;
793 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
796 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
799 send_keyboard_report();
803 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
805 if (record->event.pressed)
812 shift_interrupted[0] = true;
813 shift_interrupted[1] = true;
818 return process_action_kb(record);
821 __attribute__ ((weak))
822 const bool ascii_to_shift_lut[0x80] PROGMEM = {
823 0, 0, 0, 0, 0, 0, 0, 0,
824 0, 0, 0, 0, 0, 0, 0, 0,
825 0, 0, 0, 0, 0, 0, 0, 0,
826 0, 0, 0, 0, 0, 0, 0, 0,
827 0, 1, 1, 1, 1, 1, 1, 0,
828 1, 1, 1, 1, 0, 0, 0, 0,
829 0, 0, 0, 0, 0, 0, 0, 0,
830 0, 0, 1, 0, 1, 0, 1, 1,
831 1, 1, 1, 1, 1, 1, 1, 1,
832 1, 1, 1, 1, 1, 1, 1, 1,
833 1, 1, 1, 1, 1, 1, 1, 1,
834 1, 1, 1, 0, 0, 0, 1, 1,
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, 1, 1, 1, 1, 0
841 __attribute__ ((weak))
842 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
843 0, 0, 0, 0, 0, 0, 0, 0,
844 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
845 0, 0, 0, 0, 0, 0, 0, 0,
846 0, 0, 0, KC_ESC, 0, 0, 0, 0,
847 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
848 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
849 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
850 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
851 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
852 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
853 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
854 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
855 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
856 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
857 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
858 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
861 void send_string(const char *str) {
862 send_string_with_delay(str, 0);
865 void send_string_P(const char *str) {
866 send_string_with_delay_P(str, 0);
869 void send_string_with_delay(const char *str, uint8_t interval) {
871 char ascii_code = *str;
872 if (!ascii_code) break;
873 if (ascii_code == 1) {
875 uint8_t keycode = *(++str);
876 register_code(keycode);
877 unregister_code(keycode);
878 } else if (ascii_code == 2) {
880 uint8_t keycode = *(++str);
881 register_code(keycode);
882 } else if (ascii_code == 3) {
884 uint8_t keycode = *(++str);
885 unregister_code(keycode);
887 send_char(ascii_code);
891 { uint8_t ms = interval; while (ms--) wait_ms(1); }
895 void send_string_with_delay_P(const char *str, uint8_t interval) {
897 char ascii_code = pgm_read_byte(str);
898 if (!ascii_code) break;
899 if (ascii_code == 1) {
901 uint8_t keycode = pgm_read_byte(++str);
902 register_code(keycode);
903 unregister_code(keycode);
904 } else if (ascii_code == 2) {
906 uint8_t keycode = pgm_read_byte(++str);
907 register_code(keycode);
908 } else if (ascii_code == 3) {
910 uint8_t keycode = pgm_read_byte(++str);
911 unregister_code(keycode);
913 send_char(ascii_code);
917 { uint8_t ms = interval; while (ms--) wait_ms(1); }
921 void send_char(char ascii_code) {
923 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
924 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
925 register_code(KC_LSFT);
926 register_code(keycode);
927 unregister_code(keycode);
928 unregister_code(KC_LSFT);
930 register_code(keycode);
931 unregister_code(keycode);
935 void set_single_persistent_default_layer(uint8_t default_layer) {
936 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
937 PLAY_SONG(default_layer_songs[default_layer]);
939 eeconfig_update_default_layer(1U<<default_layer);
940 default_layer_set(1U<<default_layer);
943 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
944 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
945 uint32_t mask3 = 1UL << layer3;
946 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
949 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
950 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
953 void tap_random_base64(void) {
954 #if defined(__AVR_ATmega32U4__)
955 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
957 uint8_t key = rand() % 64;
961 register_code(KC_LSFT);
962 register_code(key + KC_A);
963 unregister_code(key + KC_A);
964 unregister_code(KC_LSFT);
967 register_code(key - 26 + KC_A);
968 unregister_code(key - 26 + KC_A);
972 unregister_code(KC_0);
975 register_code(key - 53 + KC_1);
976 unregister_code(key - 53 + KC_1);
979 register_code(KC_LSFT);
980 register_code(KC_EQL);
981 unregister_code(KC_EQL);
982 unregister_code(KC_LSFT);
985 register_code(KC_SLSH);
986 unregister_code(KC_SLSH);
991 __attribute__((weak))
992 void bootmagic_lite(void) {
993 // The lite version of TMK's bootmagic based on Wilba.
994 // 100% less potential for accidentally making the
995 // keyboard do stupid things.
997 // We need multiple scans because debouncing can't be turned off.
999 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
1000 wait_ms(DEBOUNCING_DELAY * 2);
1001 #elif defined(DEBOUNCE) && DEBOUNCE > 0
1002 wait_ms(DEBOUNCE * 2);
1008 // If the Esc and space bar are held down on power up,
1009 // reset the EEPROM valid state and jump to bootloader.
1010 // Assumes Esc is at [0,0].
1011 // This isn't very generalized, but we need something that doesn't
1012 // rely on user's keymaps in firmware or EEPROM.
1013 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
1015 // Jump to bootloader.
1020 void matrix_init_quantum() {
1021 #ifdef BOOTMAGIC_LITE
1024 if (!eeconfig_is_enabled()) {
1027 #ifdef BACKLIGHT_ENABLE
1028 #ifdef LED_MATRIX_ENABLE
1031 backlight_init_ports();
1037 #ifdef RGB_MATRIX_ENABLE
1040 #ifdef ENCODER_ENABLE
1043 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1044 unicode_input_mode_init();
1046 #ifdef HAPTIC_ENABLE
1052 uint8_t rgb_matrix_task_counter = 0;
1054 #ifndef RGB_MATRIX_SKIP_FRAMES
1055 #define RGB_MATRIX_SKIP_FRAMES 1
1058 void matrix_scan_quantum() {
1059 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1060 matrix_scan_music();
1063 #ifdef TAP_DANCE_ENABLE
1064 matrix_scan_tap_dance();
1068 matrix_scan_combo();
1071 #if defined(BACKLIGHT_ENABLE)
1072 #if defined(LED_MATRIX_ENABLE)
1074 #elif defined(BACKLIGHT_PIN)
1079 #ifdef RGB_MATRIX_ENABLE
1081 if (rgb_matrix_task_counter == 0) {
1082 rgb_matrix_update_pwm_buffers();
1084 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1087 #ifdef ENCODER_ENABLE
1091 #ifdef HAPTIC_ENABLE
1097 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1099 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1101 // depending on the pin, we use a different output compare unit
1102 #if BACKLIGHT_PIN == B7
1103 # define TCCRxA TCCR1A
1104 # define TCCRxB TCCR1B
1105 # define COMxx1 COM1C1
1106 # define OCRxx OCR1C
1108 #elif BACKLIGHT_PIN == B6
1109 # define TCCRxA TCCR1A
1110 # define TCCRxB TCCR1B
1111 # define COMxx1 COM1B1
1112 # define OCRxx OCR1B
1114 #elif BACKLIGHT_PIN == B5
1115 # define TCCRxA TCCR1A
1116 # define TCCRxB TCCR1B
1117 # define COMxx1 COM1A1
1118 # define OCRxx OCR1A
1120 #elif BACKLIGHT_PIN == C6
1121 # define TCCRxA TCCR3A
1122 # define TCCRxB TCCR3B
1123 # define COMxx1 COM1A1
1124 # define OCRxx OCR3A
1127 # define NO_HARDWARE_PWM
1130 #ifndef BACKLIGHT_ON_STATE
1131 #define BACKLIGHT_ON_STATE 0
1134 #ifdef NO_HARDWARE_PWM // pwm through software
1136 __attribute__ ((weak))
1137 void backlight_init_ports(void)
1139 // Setup backlight pin as output and output to on state.
1141 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1142 #if BACKLIGHT_ON_STATE == 0
1144 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1147 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1151 __attribute__ ((weak))
1152 void backlight_set(uint8_t level) {}
1154 uint8_t backlight_tick = 0;
1156 #ifndef BACKLIGHT_CUSTOM_DRIVER
1157 void backlight_task(void) {
1158 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1159 #if BACKLIGHT_ON_STATE == 0
1161 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1164 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1167 #if BACKLIGHT_ON_STATE == 0
1169 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1172 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1175 backlight_tick = (backlight_tick + 1) % 16;
1179 #ifdef BACKLIGHT_BREATHING
1180 #ifndef BACKLIGHT_CUSTOM_DRIVER
1181 #error "Backlight breathing only available with hardware PWM. Please disable."
1185 #else // pwm through timer
1187 #define TIMER_TOP 0xFFFFU
1189 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1190 static uint16_t cie_lightness(uint16_t v) {
1191 if (v <= 5243) // if below 8% of max
1192 return v / 9; // same as dividing by 900%
1194 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1195 // to get a useful result with integer division, we shift left in the expression above
1196 // and revert what we've done again after squaring.
1198 if (y > 0xFFFFUL) // prevent overflow
1201 return (uint16_t) y;
1205 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1206 static inline void set_pwm(uint16_t val) {
1210 #ifndef BACKLIGHT_CUSTOM_DRIVER
1211 __attribute__ ((weak))
1212 void backlight_set(uint8_t level) {
1213 if (level > BACKLIGHT_LEVELS)
1214 level = BACKLIGHT_LEVELS;
1217 // Turn off PWM control on backlight pin
1218 TCCRxA &= ~(_BV(COMxx1));
1220 // Turn on PWM control of backlight pin
1221 TCCRxA |= _BV(COMxx1);
1223 // Set the brightness
1224 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1227 void backlight_task(void) {}
1228 #endif // BACKLIGHT_CUSTOM_DRIVER
1230 #ifdef BACKLIGHT_BREATHING
1232 #define BREATHING_NO_HALT 0
1233 #define BREATHING_HALT_OFF 1
1234 #define BREATHING_HALT_ON 2
1235 #define BREATHING_STEPS 128
1237 static uint8_t breathing_period = BREATHING_PERIOD;
1238 static uint8_t breathing_halt = BREATHING_NO_HALT;
1239 static uint16_t breathing_counter = 0;
1241 bool is_breathing(void) {
1242 return !!(TIMSK1 & _BV(TOIE1));
1245 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1246 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1247 #define breathing_min() do {breathing_counter = 0;} while (0)
1248 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1250 void breathing_enable(void)
1252 breathing_counter = 0;
1253 breathing_halt = BREATHING_NO_HALT;
1254 breathing_interrupt_enable();
1257 void breathing_pulse(void)
1259 if (get_backlight_level() == 0)
1263 breathing_halt = BREATHING_HALT_ON;
1264 breathing_interrupt_enable();
1267 void breathing_disable(void)
1269 breathing_interrupt_disable();
1270 // Restore backlight level
1271 backlight_set(get_backlight_level());
1274 void breathing_self_disable(void)
1276 if (get_backlight_level() == 0)
1277 breathing_halt = BREATHING_HALT_OFF;
1279 breathing_halt = BREATHING_HALT_ON;
1282 void breathing_toggle(void) {
1284 breathing_disable();
1289 void breathing_period_set(uint8_t value)
1293 breathing_period = value;
1296 void breathing_period_default(void) {
1297 breathing_period_set(BREATHING_PERIOD);
1300 void breathing_period_inc(void)
1302 breathing_period_set(breathing_period+1);
1305 void breathing_period_dec(void)
1307 breathing_period_set(breathing_period-1);
1310 /* To generate breathing curve in python:
1311 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1313 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};
1315 // Use this before the cie_lightness function.
1316 static inline uint16_t scale_backlight(uint16_t v) {
1317 return v / BACKLIGHT_LEVELS * get_backlight_level();
1320 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1321 * about 244 times per second.
1323 ISR(TIMER1_OVF_vect)
1325 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1326 // resetting after one period to prevent ugly reset at overflow.
1327 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1328 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1330 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1331 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1333 breathing_interrupt_disable();
1336 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1339 #endif // BACKLIGHT_BREATHING
1341 __attribute__ ((weak))
1342 void backlight_init_ports(void)
1344 // Setup backlight pin as output and output to on state.
1346 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1347 #if BACKLIGHT_ON_STATE == 0
1349 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1352 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1354 // I could write a wall of text here to explain... but TL;DW
1355 // Go read the ATmega32u4 datasheet.
1356 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1358 // Pin PB7 = OCR1C (Timer 1, Channel C)
1359 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1360 // (i.e. start high, go low when counter matches.)
1361 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1362 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1366 "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 [..]."
1367 "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)."
1369 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1370 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1371 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1375 #ifdef BACKLIGHT_BREATHING
1380 #endif // NO_HARDWARE_PWM
1384 __attribute__ ((weak))
1385 void backlight_init_ports(void) {}
1387 __attribute__ ((weak))
1388 void backlight_set(uint8_t level) {}
1392 #ifdef HD44780_ENABLED
1393 #include "hd44780.h"
1397 // Functions for spitting out values
1400 void send_dword(uint32_t number) { // this might not actually work
1401 uint16_t word = (number >> 16);
1403 send_word(number & 0xFFFFUL);
1406 void send_word(uint16_t number) {
1407 uint8_t byte = number >> 8;
1409 send_byte(number & 0xFF);
1412 void send_byte(uint8_t number) {
1413 uint8_t nibble = number >> 4;
1414 send_nibble(nibble);
1415 send_nibble(number & 0xF);
1418 void send_nibble(uint8_t number) {
1421 register_code(KC_0);
1422 unregister_code(KC_0);
1425 register_code(KC_1 + (number - 1));
1426 unregister_code(KC_1 + (number - 1));
1429 register_code(KC_A + (number - 0xA));
1430 unregister_code(KC_A + (number - 0xA));
1436 __attribute__((weak))
1437 uint16_t hex_to_keycode(uint8_t hex)
1442 } else if (hex < 0xA) {
1443 return KC_1 + (hex - 0x1);
1445 return KC_A + (hex - 0xA);
1449 void api_send_unicode(uint32_t unicode) {
1452 dword_to_bytes(unicode, chunk);
1453 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1457 __attribute__ ((weak))
1458 void led_set_user(uint8_t usb_led) {
1462 __attribute__ ((weak))
1463 void led_set_kb(uint8_t usb_led) {
1464 led_set_user(usb_led);
1467 __attribute__ ((weak))
1468 void led_init_ports(void)
1473 __attribute__ ((weak))
1474 void led_set(uint8_t usb_led)
1479 // // Using PE6 Caps Lock LED
1480 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1490 // PORTE &= ~(1<<6);
1493 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1494 // Use backlight as Caps Lock indicator
1495 uint8_t bl_toggle_lvl = 0;
1497 if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1498 // Turning Caps Lock ON and backlight is disabled in config
1499 // Toggling backlight to the brightest level
1500 bl_toggle_lvl = BACKLIGHT_LEVELS;
1501 } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1502 // Turning Caps Lock OFF and backlight is enabled in config
1503 // Toggling backlight and restoring config level
1504 bl_toggle_lvl = backlight_config.level;
1507 // Set level without modify backlight_config to keep ability to restore state
1508 backlight_set(bl_toggle_lvl);
1511 led_set_kb(usb_led);
1515 //------------------------------------------------------------------------------
1516 // Override these functions in your keymap file to play different tunes on
1517 // different events such as startup and bootloader jump
1519 __attribute__ ((weak))
1520 void startup_user() {}
1522 __attribute__ ((weak))
1523 void shutdown_user() {}
1525 //------------------------------------------------------------------------------