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) {
363 #ifdef SPLIT_KEYBOARD
368 case RGB_MODE_FORWARD:
369 if (record->event.pressed) {
370 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
372 rgblight_step_reverse();
377 #ifdef SPLIT_KEYBOARD
382 case RGB_MODE_REVERSE:
383 if (record->event.pressed) {
384 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
389 rgblight_step_reverse();
391 #ifdef SPLIT_KEYBOARD
397 // Split keyboards need to trigger on key-up for edge-case issue
398 #ifndef SPLIT_KEYBOARD
399 if (record->event.pressed) {
401 if (!record->event.pressed) {
403 rgblight_increase_hue();
404 #ifdef SPLIT_KEYBOARD
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();
417 #ifdef SPLIT_KEYBOARD
423 // Split keyboards need to trigger on key-up for edge-case issue
424 #ifndef SPLIT_KEYBOARD
425 if (record->event.pressed) {
427 if (!record->event.pressed) {
429 rgblight_increase_sat();
430 #ifdef SPLIT_KEYBOARD
436 // Split keyboards need to trigger on key-up for edge-case issue
437 #ifndef SPLIT_KEYBOARD
438 if (record->event.pressed) {
440 if (!record->event.pressed) {
442 rgblight_decrease_sat();
443 #ifdef SPLIT_KEYBOARD
449 // Split keyboards need to trigger on key-up for edge-case issue
450 #ifndef SPLIT_KEYBOARD
451 if (record->event.pressed) {
453 if (!record->event.pressed) {
455 rgblight_increase_val();
456 #ifdef SPLIT_KEYBOARD
462 // Split keyboards need to trigger on key-up for edge-case issue
463 #ifndef SPLIT_KEYBOARD
464 if (record->event.pressed) {
466 if (!record->event.pressed) {
468 rgblight_decrease_val();
469 #ifdef SPLIT_KEYBOARD
475 if (record->event.pressed) {
476 rgblight_increase_speed();
480 if (record->event.pressed) {
481 rgblight_decrease_speed();
485 if (record->event.pressed) {
486 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
487 #ifdef SPLIT_KEYBOARD
492 case RGB_MODE_BREATHE:
493 #ifdef RGBLIGHT_EFFECT_BREATHING
494 if (record->event.pressed) {
495 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
496 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
499 rgblight_mode(RGBLIGHT_MODE_BREATHING);
504 case RGB_MODE_RAINBOW:
505 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
506 if (record->event.pressed) {
507 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
508 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
511 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
517 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
518 if (record->event.pressed) {
519 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
520 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
523 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
529 #ifdef RGBLIGHT_EFFECT_SNAKE
530 if (record->event.pressed) {
531 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
532 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
535 rgblight_mode(RGBLIGHT_MODE_SNAKE);
540 case RGB_MODE_KNIGHT:
541 #ifdef RGBLIGHT_EFFECT_KNIGHT
542 if (record->event.pressed) {
543 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
544 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
547 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
553 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
554 if (record->event.pressed) {
555 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
559 case RGB_MODE_GRADIENT:
560 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
561 if (record->event.pressed) {
562 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
563 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
566 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
571 case RGB_MODE_RGBTEST:
572 #ifdef RGBLIGHT_EFFECT_RGB_TEST
573 if (record->event.pressed) {
574 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
578 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
579 #ifdef VELOCIKEY_ENABLE
581 if (record->event.pressed) {
588 if (record->event.pressed) {
589 set_output(OUTPUT_AUTO);
593 if (record->event.pressed) {
594 set_output(OUTPUT_USB);
597 #ifdef BLUETOOTH_ENABLE
599 if (record->event.pressed) {
600 set_output(OUTPUT_BLUETOOTH);
605 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
606 if (record->event.pressed) {
607 // MAGIC actions (BOOTMAGIC without the boot)
608 if (!eeconfig_is_enabled()) {
612 keymap_config.raw = eeconfig_read_keymap();
615 case MAGIC_SWAP_CONTROL_CAPSLOCK:
616 keymap_config.swap_control_capslock = true;
618 case MAGIC_CAPSLOCK_TO_CONTROL:
619 keymap_config.capslock_to_control = true;
621 case MAGIC_SWAP_LALT_LGUI:
622 keymap_config.swap_lalt_lgui = true;
624 case MAGIC_SWAP_RALT_RGUI:
625 keymap_config.swap_ralt_rgui = true;
628 keymap_config.no_gui = true;
630 case MAGIC_SWAP_GRAVE_ESC:
631 keymap_config.swap_grave_esc = true;
633 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
634 keymap_config.swap_backslash_backspace = true;
636 case MAGIC_HOST_NKRO:
637 keymap_config.nkro = true;
639 case MAGIC_SWAP_ALT_GUI:
640 keymap_config.swap_lalt_lgui = true;
641 keymap_config.swap_ralt_rgui = true;
643 PLAY_SONG(ag_swap_song);
646 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
647 keymap_config.swap_control_capslock = false;
649 case MAGIC_UNCAPSLOCK_TO_CONTROL:
650 keymap_config.capslock_to_control = false;
652 case MAGIC_UNSWAP_LALT_LGUI:
653 keymap_config.swap_lalt_lgui = false;
655 case MAGIC_UNSWAP_RALT_RGUI:
656 keymap_config.swap_ralt_rgui = false;
659 keymap_config.no_gui = false;
661 case MAGIC_UNSWAP_GRAVE_ESC:
662 keymap_config.swap_grave_esc = false;
664 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
665 keymap_config.swap_backslash_backspace = false;
667 case MAGIC_UNHOST_NKRO:
668 keymap_config.nkro = false;
670 case MAGIC_UNSWAP_ALT_GUI:
671 keymap_config.swap_lalt_lgui = false;
672 keymap_config.swap_ralt_rgui = false;
674 PLAY_SONG(ag_norm_song);
677 case MAGIC_TOGGLE_ALT_GUI:
678 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
679 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
681 if (keymap_config.swap_ralt_rgui) {
682 PLAY_SONG(ag_swap_song);
684 PLAY_SONG(ag_norm_song);
688 case MAGIC_TOGGLE_NKRO:
689 keymap_config.nkro = !keymap_config.nkro;
694 eeconfig_update_keymap(keymap_config.raw);
695 clear_keyboard(); // clear to prevent stuck keys
701 if (record->event.pressed) {
702 shift_interrupted[0] = false;
703 scs_timer[0] = timer_read ();
704 register_mods(MOD_BIT(KC_LSFT));
707 #ifdef DISABLE_SPACE_CADET_ROLLOVER
708 if (get_mods() & MOD_BIT(RSPC_MOD)) {
709 shift_interrupted[0] = true;
710 shift_interrupted[1] = true;
713 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
714 #ifdef DISABLE_SPACE_CADET_MODIFIER
715 unregister_mods(MOD_BIT(KC_LSFT));
717 if( LSPO_MOD != KC_LSFT ){
718 unregister_mods(MOD_BIT(KC_LSFT));
719 register_mods(MOD_BIT(LSPO_MOD));
722 register_code(LSPO_KEY);
723 unregister_code(LSPO_KEY);
724 #ifndef DISABLE_SPACE_CADET_MODIFIER
725 if( LSPO_MOD != KC_LSFT ){
726 unregister_mods(MOD_BIT(LSPO_MOD));
730 unregister_mods(MOD_BIT(KC_LSFT));
736 if (record->event.pressed) {
737 shift_interrupted[1] = false;
738 scs_timer[1] = timer_read ();
739 register_mods(MOD_BIT(KC_RSFT));
742 #ifdef DISABLE_SPACE_CADET_ROLLOVER
743 if (get_mods() & MOD_BIT(LSPO_MOD)) {
744 shift_interrupted[0] = true;
745 shift_interrupted[1] = true;
748 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
749 #ifdef DISABLE_SPACE_CADET_MODIFIER
750 unregister_mods(MOD_BIT(KC_RSFT));
752 if( RSPC_MOD != KC_RSFT ){
753 unregister_mods(MOD_BIT(KC_RSFT));
754 register_mods(MOD_BIT(RSPC_MOD));
757 register_code(RSPC_KEY);
758 unregister_code(RSPC_KEY);
759 #ifndef DISABLE_SPACE_CADET_MODIFIER
760 if ( RSPC_MOD != KC_RSFT ){
761 unregister_mods(MOD_BIT(RSPC_MOD));
765 unregister_mods(MOD_BIT(KC_RSFT));
771 if (record->event.pressed) {
772 shift_interrupted[1] = false;
773 scs_timer[1] = timer_read ();
774 register_mods(MOD_BIT(KC_RSFT));
776 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
777 unregister_mods(MOD_BIT(KC_RSFT));
778 register_code(SFTENT_KEY);
779 unregister_code(SFTENT_KEY);
782 unregister_mods(MOD_BIT(KC_RSFT));
788 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
789 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
791 #ifdef GRAVE_ESC_ALT_OVERRIDE
792 // if ALT is pressed, ESC is always sent
793 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
794 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
799 #ifdef GRAVE_ESC_CTRL_OVERRIDE
800 // if CTRL is pressed, ESC is always sent
801 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
802 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
807 #ifdef GRAVE_ESC_GUI_OVERRIDE
808 // if GUI is pressed, ESC is always sent
809 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
814 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
815 // if SHIFT is pressed, ESC is always sent
816 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
821 if (record->event.pressed) {
822 grave_esc_was_shifted = shifted;
823 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
826 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
829 send_keyboard_report();
833 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
835 if (record->event.pressed)
842 shift_interrupted[0] = true;
843 shift_interrupted[1] = true;
848 return process_action_kb(record);
851 __attribute__ ((weak))
852 const bool ascii_to_shift_lut[0x80] PROGMEM = {
853 0, 0, 0, 0, 0, 0, 0, 0,
854 0, 0, 0, 0, 0, 0, 0, 0,
855 0, 0, 0, 0, 0, 0, 0, 0,
856 0, 0, 0, 0, 0, 0, 0, 0,
857 0, 1, 1, 1, 1, 1, 1, 0,
858 1, 1, 1, 1, 0, 0, 0, 0,
859 0, 0, 0, 0, 0, 0, 0, 0,
860 0, 0, 1, 0, 1, 0, 1, 1,
861 1, 1, 1, 1, 1, 1, 1, 1,
862 1, 1, 1, 1, 1, 1, 1, 1,
863 1, 1, 1, 1, 1, 1, 1, 1,
864 1, 1, 1, 0, 0, 0, 1, 1,
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, 1, 1, 1, 1, 0
871 __attribute__ ((weak))
872 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
873 0, 0, 0, 0, 0, 0, 0, 0,
874 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
875 0, 0, 0, 0, 0, 0, 0, 0,
876 0, 0, 0, KC_ESC, 0, 0, 0, 0,
877 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
878 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
879 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
880 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
881 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
882 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
883 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
884 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
885 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
886 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
887 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
888 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
891 void send_string(const char *str) {
892 send_string_with_delay(str, 0);
895 void send_string_P(const char *str) {
896 send_string_with_delay_P(str, 0);
899 void send_string_with_delay(const char *str, uint8_t interval) {
901 char ascii_code = *str;
902 if (!ascii_code) break;
903 if (ascii_code == 1) {
905 uint8_t keycode = *(++str);
906 register_code(keycode);
907 unregister_code(keycode);
908 } else if (ascii_code == 2) {
910 uint8_t keycode = *(++str);
911 register_code(keycode);
912 } else if (ascii_code == 3) {
914 uint8_t keycode = *(++str);
915 unregister_code(keycode);
917 send_char(ascii_code);
921 { uint8_t ms = interval; while (ms--) wait_ms(1); }
925 void send_string_with_delay_P(const char *str, uint8_t interval) {
927 char ascii_code = pgm_read_byte(str);
928 if (!ascii_code) break;
929 if (ascii_code == 1) {
931 uint8_t keycode = pgm_read_byte(++str);
932 register_code(keycode);
933 unregister_code(keycode);
934 } else if (ascii_code == 2) {
936 uint8_t keycode = pgm_read_byte(++str);
937 register_code(keycode);
938 } else if (ascii_code == 3) {
940 uint8_t keycode = pgm_read_byte(++str);
941 unregister_code(keycode);
943 send_char(ascii_code);
947 { uint8_t ms = interval; while (ms--) wait_ms(1); }
951 void send_char(char ascii_code) {
953 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
954 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
955 register_code(KC_LSFT);
956 register_code(keycode);
957 unregister_code(keycode);
958 unregister_code(KC_LSFT);
960 register_code(keycode);
961 unregister_code(keycode);
965 void set_single_persistent_default_layer(uint8_t default_layer) {
966 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
967 PLAY_SONG(default_layer_songs[default_layer]);
969 eeconfig_update_default_layer(1U<<default_layer);
970 default_layer_set(1U<<default_layer);
973 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
974 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
975 uint32_t mask3 = 1UL << layer3;
976 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
979 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
980 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
983 void tap_random_base64(void) {
984 #if defined(__AVR_ATmega32U4__)
985 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
987 uint8_t key = rand() % 64;
991 register_code(KC_LSFT);
992 register_code(key + KC_A);
993 unregister_code(key + KC_A);
994 unregister_code(KC_LSFT);
997 register_code(key - 26 + KC_A);
998 unregister_code(key - 26 + KC_A);
1001 register_code(KC_0);
1002 unregister_code(KC_0);
1005 register_code(key - 53 + KC_1);
1006 unregister_code(key - 53 + KC_1);
1009 register_code(KC_LSFT);
1010 register_code(KC_EQL);
1011 unregister_code(KC_EQL);
1012 unregister_code(KC_LSFT);
1015 register_code(KC_SLSH);
1016 unregister_code(KC_SLSH);
1021 __attribute__((weak))
1022 void bootmagic_lite(void) {
1023 // The lite version of TMK's bootmagic based on Wilba.
1024 // 100% less potential for accidentally making the
1025 // keyboard do stupid things.
1027 // We need multiple scans because debouncing can't be turned off.
1029 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
1030 wait_ms(DEBOUNCING_DELAY * 2);
1031 #elif defined(DEBOUNCE) && DEBOUNCE > 0
1032 wait_ms(DEBOUNCE * 2);
1038 // If the Esc and space bar are held down on power up,
1039 // reset the EEPROM valid state and jump to bootloader.
1040 // Assumes Esc is at [0,0].
1041 // This isn't very generalized, but we need something that doesn't
1042 // rely on user's keymaps in firmware or EEPROM.
1043 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
1045 // Jump to bootloader.
1050 void matrix_init_quantum() {
1051 #ifdef BOOTMAGIC_LITE
1054 if (!eeconfig_is_enabled()) {
1057 #ifdef BACKLIGHT_ENABLE
1058 #ifdef LED_MATRIX_ENABLE
1061 backlight_init_ports();
1067 #ifdef RGB_MATRIX_ENABLE
1070 #ifdef ENCODER_ENABLE
1073 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1074 unicode_input_mode_init();
1076 #ifdef HAPTIC_ENABLE
1082 uint8_t rgb_matrix_task_counter = 0;
1084 #ifndef RGB_MATRIX_SKIP_FRAMES
1085 #define RGB_MATRIX_SKIP_FRAMES 1
1088 void matrix_scan_quantum() {
1089 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1090 matrix_scan_music();
1093 #ifdef TAP_DANCE_ENABLE
1094 matrix_scan_tap_dance();
1098 matrix_scan_combo();
1101 #if defined(BACKLIGHT_ENABLE)
1102 #if defined(LED_MATRIX_ENABLE)
1104 #elif defined(BACKLIGHT_PIN)
1109 #ifdef RGB_MATRIX_ENABLE
1111 if (rgb_matrix_task_counter == 0) {
1112 rgb_matrix_update_pwm_buffers();
1114 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1117 #ifdef ENCODER_ENABLE
1121 #ifdef HAPTIC_ENABLE
1127 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1129 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1131 // depending on the pin, we use a different output compare unit
1132 #if BACKLIGHT_PIN == B7
1133 # define TCCRxA TCCR1A
1134 # define TCCRxB TCCR1B
1135 # define COMxx1 COM1C1
1136 # define OCRxx OCR1C
1138 #elif BACKLIGHT_PIN == B6
1139 # define TCCRxA TCCR1A
1140 # define TCCRxB TCCR1B
1141 # define COMxx1 COM1B1
1142 # define OCRxx OCR1B
1144 #elif BACKLIGHT_PIN == B5
1145 # define TCCRxA TCCR1A
1146 # define TCCRxB TCCR1B
1147 # define COMxx1 COM1A1
1148 # define OCRxx OCR1A
1150 #elif BACKLIGHT_PIN == C6
1151 # define TCCRxA TCCR3A
1152 # define TCCRxB TCCR3B
1153 # define COMxx1 COM1A1
1154 # define OCRxx OCR3A
1157 # define NO_HARDWARE_PWM
1160 #ifndef BACKLIGHT_ON_STATE
1161 #define BACKLIGHT_ON_STATE 0
1164 #ifdef NO_HARDWARE_PWM // pwm through software
1166 __attribute__ ((weak))
1167 void backlight_init_ports(void)
1169 // Setup backlight pin as output and output to on state.
1171 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1172 #if BACKLIGHT_ON_STATE == 0
1174 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1177 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1181 __attribute__ ((weak))
1182 void backlight_set(uint8_t level) {}
1184 uint8_t backlight_tick = 0;
1186 #ifndef BACKLIGHT_CUSTOM_DRIVER
1187 void backlight_task(void) {
1188 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1189 #if BACKLIGHT_ON_STATE == 0
1191 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1194 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1197 #if BACKLIGHT_ON_STATE == 0
1199 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1202 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1205 backlight_tick = (backlight_tick + 1) % 16;
1209 #ifdef BACKLIGHT_BREATHING
1210 #ifndef BACKLIGHT_CUSTOM_DRIVER
1211 #error "Backlight breathing only available with hardware PWM. Please disable."
1215 #else // pwm through timer
1217 #define TIMER_TOP 0xFFFFU
1219 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1220 static uint16_t cie_lightness(uint16_t v) {
1221 if (v <= 5243) // if below 8% of max
1222 return v / 9; // same as dividing by 900%
1224 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1225 // to get a useful result with integer division, we shift left in the expression above
1226 // and revert what we've done again after squaring.
1228 if (y > 0xFFFFUL) // prevent overflow
1231 return (uint16_t) y;
1235 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1236 static inline void set_pwm(uint16_t val) {
1240 #ifndef BACKLIGHT_CUSTOM_DRIVER
1241 __attribute__ ((weak))
1242 void backlight_set(uint8_t level) {
1243 if (level > BACKLIGHT_LEVELS)
1244 level = BACKLIGHT_LEVELS;
1247 // Turn off PWM control on backlight pin
1248 TCCRxA &= ~(_BV(COMxx1));
1250 // Turn on PWM control of backlight pin
1251 TCCRxA |= _BV(COMxx1);
1253 // Set the brightness
1254 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1257 void backlight_task(void) {}
1258 #endif // BACKLIGHT_CUSTOM_DRIVER
1260 #ifdef BACKLIGHT_BREATHING
1262 #define BREATHING_NO_HALT 0
1263 #define BREATHING_HALT_OFF 1
1264 #define BREATHING_HALT_ON 2
1265 #define BREATHING_STEPS 128
1267 static uint8_t breathing_period = BREATHING_PERIOD;
1268 static uint8_t breathing_halt = BREATHING_NO_HALT;
1269 static uint16_t breathing_counter = 0;
1271 bool is_breathing(void) {
1272 return !!(TIMSK1 & _BV(TOIE1));
1275 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1276 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1277 #define breathing_min() do {breathing_counter = 0;} while (0)
1278 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1280 void breathing_enable(void)
1282 breathing_counter = 0;
1283 breathing_halt = BREATHING_NO_HALT;
1284 breathing_interrupt_enable();
1287 void breathing_pulse(void)
1289 if (get_backlight_level() == 0)
1293 breathing_halt = BREATHING_HALT_ON;
1294 breathing_interrupt_enable();
1297 void breathing_disable(void)
1299 breathing_interrupt_disable();
1300 // Restore backlight level
1301 backlight_set(get_backlight_level());
1304 void breathing_self_disable(void)
1306 if (get_backlight_level() == 0)
1307 breathing_halt = BREATHING_HALT_OFF;
1309 breathing_halt = BREATHING_HALT_ON;
1312 void breathing_toggle(void) {
1314 breathing_disable();
1319 void breathing_period_set(uint8_t value)
1323 breathing_period = value;
1326 void breathing_period_default(void) {
1327 breathing_period_set(BREATHING_PERIOD);
1330 void breathing_period_inc(void)
1332 breathing_period_set(breathing_period+1);
1335 void breathing_period_dec(void)
1337 breathing_period_set(breathing_period-1);
1340 /* To generate breathing curve in python:
1341 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1343 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};
1345 // Use this before the cie_lightness function.
1346 static inline uint16_t scale_backlight(uint16_t v) {
1347 return v / BACKLIGHT_LEVELS * get_backlight_level();
1350 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1351 * about 244 times per second.
1353 ISR(TIMER1_OVF_vect)
1355 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1356 // resetting after one period to prevent ugly reset at overflow.
1357 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1358 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1360 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1361 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1363 breathing_interrupt_disable();
1366 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1369 #endif // BACKLIGHT_BREATHING
1371 __attribute__ ((weak))
1372 void backlight_init_ports(void)
1374 // Setup backlight pin as output and output to on state.
1376 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1377 #if BACKLIGHT_ON_STATE == 0
1379 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1382 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1384 // I could write a wall of text here to explain... but TL;DW
1385 // Go read the ATmega32u4 datasheet.
1386 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1388 // Pin PB7 = OCR1C (Timer 1, Channel C)
1389 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1390 // (i.e. start high, go low when counter matches.)
1391 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1392 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1396 "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 [..]."
1397 "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)."
1399 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1400 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1401 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1405 #ifdef BACKLIGHT_BREATHING
1410 #endif // NO_HARDWARE_PWM
1414 __attribute__ ((weak))
1415 void backlight_init_ports(void) {}
1417 __attribute__ ((weak))
1418 void backlight_set(uint8_t level) {}
1422 #ifdef HD44780_ENABLED
1423 #include "hd44780.h"
1427 // Functions for spitting out values
1430 void send_dword(uint32_t number) { // this might not actually work
1431 uint16_t word = (number >> 16);
1433 send_word(number & 0xFFFFUL);
1436 void send_word(uint16_t number) {
1437 uint8_t byte = number >> 8;
1439 send_byte(number & 0xFF);
1442 void send_byte(uint8_t number) {
1443 uint8_t nibble = number >> 4;
1444 send_nibble(nibble);
1445 send_nibble(number & 0xF);
1448 void send_nibble(uint8_t number) {
1451 register_code(KC_0);
1452 unregister_code(KC_0);
1455 register_code(KC_1 + (number - 1));
1456 unregister_code(KC_1 + (number - 1));
1459 register_code(KC_A + (number - 0xA));
1460 unregister_code(KC_A + (number - 0xA));
1466 __attribute__((weak))
1467 uint16_t hex_to_keycode(uint8_t hex)
1472 } else if (hex < 0xA) {
1473 return KC_1 + (hex - 0x1);
1475 return KC_A + (hex - 0xA);
1479 void api_send_unicode(uint32_t unicode) {
1482 dword_to_bytes(unicode, chunk);
1483 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1487 __attribute__ ((weak))
1488 void led_set_user(uint8_t usb_led) {
1492 __attribute__ ((weak))
1493 void led_set_kb(uint8_t usb_led) {
1494 led_set_user(usb_led);
1497 __attribute__ ((weak))
1498 void led_init_ports(void)
1503 __attribute__ ((weak))
1504 void led_set(uint8_t usb_led)
1509 // // Using PE6 Caps Lock LED
1510 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1520 // PORTE &= ~(1<<6);
1523 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1524 // Use backlight as Caps Lock indicator
1525 uint8_t bl_toggle_lvl = 0;
1527 if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1528 // Turning Caps Lock ON and backlight is disabled in config
1529 // Toggling backlight to the brightest level
1530 bl_toggle_lvl = BACKLIGHT_LEVELS;
1531 } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1532 // Turning Caps Lock OFF and backlight is enabled in config
1533 // Toggling backlight and restoring config level
1534 bl_toggle_lvl = backlight_config.level;
1537 // Set level without modify backlight_config to keep ability to restore state
1538 backlight_set(bl_toggle_lvl);
1541 led_set_kb(usb_led);
1545 //------------------------------------------------------------------------------
1546 // Override these functions in your keymap file to play different tunes on
1547 // different events such as startup and bootloader jump
1549 __attribute__ ((weak))
1550 void startup_user() {}
1552 __attribute__ ((weak))
1553 void shutdown_user() {}
1555 //------------------------------------------------------------------------------