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"
60 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
63 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
66 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
68 float goodbye_song[][2] = GOODBYE_SONG;
69 float ag_norm_song[][2] = AG_NORM_SONG;
70 float ag_swap_song[][2] = AG_SWAP_SONG;
71 #ifdef DEFAULT_LAYER_SONGS
72 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
76 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
78 case QK_MODS ... QK_MODS_MAX:
93 if (code < QK_RMODS_MIN) return;
105 static inline void qk_register_weak_mods(uint8_t kc) {
106 add_weak_mods(MOD_BIT(kc));
107 send_keyboard_report();
110 static inline void qk_unregister_weak_mods(uint8_t kc) {
111 del_weak_mods(MOD_BIT(kc));
112 send_keyboard_report();
115 static inline void qk_register_mods(uint8_t kc) {
116 add_weak_mods(MOD_BIT(kc));
117 send_keyboard_report();
120 static inline void qk_unregister_mods(uint8_t kc) {
121 del_weak_mods(MOD_BIT(kc));
122 send_keyboard_report();
125 void register_code16 (uint16_t code) {
126 if (IS_MOD(code) || code == KC_NO) {
127 do_code16 (code, qk_register_mods);
129 do_code16 (code, qk_register_weak_mods);
131 register_code (code);
134 void unregister_code16 (uint16_t code) {
135 unregister_code (code);
136 if (IS_MOD(code) || code == KC_NO) {
137 do_code16 (code, qk_unregister_mods);
139 do_code16 (code, qk_unregister_weak_mods);
143 void tap_code16(uint16_t code) {
144 register_code16(code);
145 #if TAP_CODE_DELAY > 0
146 wait_ms(TAP_CODE_DELAY);
148 unregister_code16(code);
151 __attribute__ ((weak))
152 bool process_action_kb(keyrecord_t *record) {
156 __attribute__ ((weak))
157 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
158 return process_record_user(keycode, record);
161 __attribute__ ((weak))
162 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
166 void reset_keyboard(void) {
168 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
169 process_midi_all_notes_off();
172 #ifndef NO_MUSIC_MODE
173 music_all_notes_off();
175 uint16_t timer_start = timer_read();
176 PLAY_SONG(goodbye_song);
178 while(timer_elapsed(timer_start) < 250)
188 // this is also done later in bootloader.c - not sure if it's neccesary here
189 #ifdef BOOTLOADER_CATERINA
190 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
195 // Shift / paren setup
198 #define LSPO_KEY KC_9
201 #define RSPC_KEY KC_0
205 #define LSPO_MOD KC_LSFT
208 #define RSPC_MOD KC_RSFT
211 // Shift / Enter setup
213 #define SFTENT_KEY KC_ENT
216 static bool shift_interrupted[2] = {0, 0};
217 static uint16_t scs_timer[2] = {0, 0};
219 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
220 * Used to ensure that the correct keycode is released if the key is released.
222 static bool grave_esc_was_shifted = false;
224 bool process_record_quantum(keyrecord_t *record) {
226 /* This gets the keycode from the key pressed */
227 keypos_t key = record->event.key;
230 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
231 /* TODO: Use store_or_get_action() or a similar function. */
232 if (!disable_action_cache) {
235 if (record->event.pressed) {
236 layer = layer_switch_get_layer(key);
237 update_source_layers_cache(key, layer);
239 layer = read_source_layers_cache(key);
241 keycode = keymap_key_to_keycode(layer, key);
244 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
246 // This is how you use actions here
247 // if (keycode == KC_LEAD) {
249 // action.code = ACTION_DEFAULT_LAYER_SET(0);
250 // process_action(record, action);
254 #ifdef TAP_DANCE_ENABLE
255 preprocess_tap_dance(keycode, record);
259 #if defined(KEY_LOCK_ENABLE)
260 // Must run first to be able to mask key_up events.
261 process_key_lock(&keycode, record) &&
263 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
264 process_clicky(keycode, record) &&
265 #endif //AUDIO_CLICKY
267 process_haptic(keycode, record) &&
268 #endif //HAPTIC_ENABLE
269 process_record_kb(keycode, record) &&
270 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
271 process_rgb_matrix(keycode, record) &&
273 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
274 process_midi(keycode, record) &&
277 process_audio(keycode, record) &&
280 process_steno(keycode, record) &&
282 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
283 process_music(keycode, record) &&
285 #ifdef TAP_DANCE_ENABLE
286 process_tap_dance(keycode, record) &&
288 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
289 process_unicode_common(keycode, record) &&
292 process_leader(keycode, record) &&
295 process_combo(keycode, record) &&
297 #ifdef PRINTING_ENABLE
298 process_printer(keycode, record) &&
300 #ifdef AUTO_SHIFT_ENABLE
301 process_auto_shift(keycode, record) &&
303 #ifdef TERMINAL_ENABLE
304 process_terminal(keycode, record) &&
310 // Shift / paren setup
314 if (record->event.pressed) {
319 if (record->event.pressed) {
321 print("DEBUG: enabled.\n");
325 if (record->event.pressed) {
329 #ifdef FAUXCLICKY_ENABLE
331 if (record->event.pressed) {
336 if (record->event.pressed) {
341 if (record->event.pressed) {
346 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
348 // Split keyboards need to trigger on key-up for edge-case issue
349 #ifndef SPLIT_KEYBOARD
350 if (record->event.pressed) {
352 if (!record->event.pressed) {
355 #ifdef SPLIT_KEYBOARD
360 case RGB_MODE_FORWARD:
361 if (record->event.pressed) {
362 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
364 rgblight_step_reverse();
369 #ifdef SPLIT_KEYBOARD
374 case RGB_MODE_REVERSE:
375 if (record->event.pressed) {
376 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
381 rgblight_step_reverse();
383 #ifdef SPLIT_KEYBOARD
389 // Split keyboards need to trigger on key-up for edge-case issue
390 #ifndef SPLIT_KEYBOARD
391 if (record->event.pressed) {
393 if (!record->event.pressed) {
395 rgblight_increase_hue();
396 #ifdef SPLIT_KEYBOARD
402 // Split keyboards need to trigger on key-up for edge-case issue
403 #ifndef SPLIT_KEYBOARD
404 if (record->event.pressed) {
406 if (!record->event.pressed) {
408 rgblight_decrease_hue();
409 #ifdef SPLIT_KEYBOARD
415 // Split keyboards need to trigger on key-up for edge-case issue
416 #ifndef SPLIT_KEYBOARD
417 if (record->event.pressed) {
419 if (!record->event.pressed) {
421 rgblight_increase_sat();
422 #ifdef SPLIT_KEYBOARD
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_decrease_sat();
435 #ifdef SPLIT_KEYBOARD
441 // Split keyboards need to trigger on key-up for edge-case issue
442 #ifndef SPLIT_KEYBOARD
443 if (record->event.pressed) {
445 if (!record->event.pressed) {
447 rgblight_increase_val();
448 #ifdef SPLIT_KEYBOARD
454 // Split keyboards need to trigger on key-up for edge-case issue
455 #ifndef SPLIT_KEYBOARD
456 if (record->event.pressed) {
458 if (!record->event.pressed) {
460 rgblight_decrease_val();
461 #ifdef SPLIT_KEYBOARD
467 if (record->event.pressed) {
468 rgblight_increase_speed();
472 if (record->event.pressed) {
473 rgblight_decrease_speed();
477 if (record->event.pressed) {
478 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
479 #ifdef SPLIT_KEYBOARD
484 case RGB_MODE_BREATHE:
485 #ifdef RGBLIGHT_EFFECT_BREATHING
486 if (record->event.pressed) {
487 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
488 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
491 rgblight_mode(RGBLIGHT_MODE_BREATHING);
496 case RGB_MODE_RAINBOW:
497 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
498 if (record->event.pressed) {
499 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
500 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
503 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
509 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
510 if (record->event.pressed) {
511 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
512 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
515 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
521 #ifdef RGBLIGHT_EFFECT_SNAKE
522 if (record->event.pressed) {
523 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
524 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
527 rgblight_mode(RGBLIGHT_MODE_SNAKE);
532 case RGB_MODE_KNIGHT:
533 #ifdef RGBLIGHT_EFFECT_KNIGHT
534 if (record->event.pressed) {
535 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
536 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
539 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
545 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
546 if (record->event.pressed) {
547 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
551 case RGB_MODE_GRADIENT:
552 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
553 if (record->event.pressed) {
554 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
555 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
558 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
563 case RGB_MODE_RGBTEST:
564 #ifdef RGBLIGHT_EFFECT_RGB_TEST
565 if (record->event.pressed) {
566 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
570 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
573 if (record->event.pressed) {
574 set_output(OUTPUT_AUTO);
578 if (record->event.pressed) {
579 set_output(OUTPUT_USB);
582 #ifdef BLUETOOTH_ENABLE
584 if (record->event.pressed) {
585 set_output(OUTPUT_BLUETOOTH);
590 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
591 if (record->event.pressed) {
592 // MAGIC actions (BOOTMAGIC without the boot)
593 if (!eeconfig_is_enabled()) {
597 keymap_config.raw = eeconfig_read_keymap();
600 case MAGIC_SWAP_CONTROL_CAPSLOCK:
601 keymap_config.swap_control_capslock = true;
603 case MAGIC_CAPSLOCK_TO_CONTROL:
604 keymap_config.capslock_to_control = true;
606 case MAGIC_SWAP_LALT_LGUI:
607 keymap_config.swap_lalt_lgui = true;
609 case MAGIC_SWAP_RALT_RGUI:
610 keymap_config.swap_ralt_rgui = true;
613 keymap_config.no_gui = true;
615 case MAGIC_SWAP_GRAVE_ESC:
616 keymap_config.swap_grave_esc = true;
618 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
619 keymap_config.swap_backslash_backspace = true;
621 case MAGIC_HOST_NKRO:
622 keymap_config.nkro = true;
624 case MAGIC_SWAP_ALT_GUI:
625 keymap_config.swap_lalt_lgui = true;
626 keymap_config.swap_ralt_rgui = true;
628 PLAY_SONG(ag_swap_song);
631 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
632 keymap_config.swap_control_capslock = false;
634 case MAGIC_UNCAPSLOCK_TO_CONTROL:
635 keymap_config.capslock_to_control = false;
637 case MAGIC_UNSWAP_LALT_LGUI:
638 keymap_config.swap_lalt_lgui = false;
640 case MAGIC_UNSWAP_RALT_RGUI:
641 keymap_config.swap_ralt_rgui = false;
644 keymap_config.no_gui = false;
646 case MAGIC_UNSWAP_GRAVE_ESC:
647 keymap_config.swap_grave_esc = false;
649 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
650 keymap_config.swap_backslash_backspace = false;
652 case MAGIC_UNHOST_NKRO:
653 keymap_config.nkro = false;
655 case MAGIC_UNSWAP_ALT_GUI:
656 keymap_config.swap_lalt_lgui = false;
657 keymap_config.swap_ralt_rgui = false;
659 PLAY_SONG(ag_norm_song);
662 case MAGIC_TOGGLE_ALT_GUI:
663 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
664 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
666 if (keymap_config.swap_ralt_rgui) {
667 PLAY_SONG(ag_swap_song);
669 PLAY_SONG(ag_norm_song);
673 case MAGIC_TOGGLE_NKRO:
674 keymap_config.nkro = !keymap_config.nkro;
679 eeconfig_update_keymap(keymap_config.raw);
680 clear_keyboard(); // clear to prevent stuck keys
686 if (record->event.pressed) {
687 shift_interrupted[0] = false;
688 scs_timer[0] = timer_read ();
689 register_mods(MOD_BIT(KC_LSFT));
692 #ifdef DISABLE_SPACE_CADET_ROLLOVER
693 if (get_mods() & MOD_BIT(RSPC_MOD)) {
694 shift_interrupted[0] = true;
695 shift_interrupted[1] = true;
698 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
699 #ifdef DISABLE_SPACE_CADET_MODIFIER
700 unregister_mods(MOD_BIT(KC_LSFT));
702 if( LSPO_MOD != KC_LSFT ){
703 unregister_mods(MOD_BIT(KC_LSFT));
704 register_mods(MOD_BIT(LSPO_MOD));
707 register_code(LSPO_KEY);
708 unregister_code(LSPO_KEY);
709 #ifndef DISABLE_SPACE_CADET_MODIFIER
710 if( LSPO_MOD != KC_LSFT ){
711 unregister_mods(MOD_BIT(LSPO_MOD));
715 unregister_mods(MOD_BIT(KC_LSFT));
721 if (record->event.pressed) {
722 shift_interrupted[1] = false;
723 scs_timer[1] = timer_read ();
724 register_mods(MOD_BIT(KC_RSFT));
727 #ifdef DISABLE_SPACE_CADET_ROLLOVER
728 if (get_mods() & MOD_BIT(LSPO_MOD)) {
729 shift_interrupted[0] = true;
730 shift_interrupted[1] = true;
733 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
734 #ifdef DISABLE_SPACE_CADET_MODIFIER
735 unregister_mods(MOD_BIT(KC_RSFT));
737 if( RSPC_MOD != KC_RSFT ){
738 unregister_mods(MOD_BIT(KC_RSFT));
739 register_mods(MOD_BIT(RSPC_MOD));
742 register_code(RSPC_KEY);
743 unregister_code(RSPC_KEY);
744 #ifndef DISABLE_SPACE_CADET_MODIFIER
745 if ( RSPC_MOD != KC_RSFT ){
746 unregister_mods(MOD_BIT(RSPC_MOD));
750 unregister_mods(MOD_BIT(KC_RSFT));
756 if (record->event.pressed) {
757 shift_interrupted[1] = false;
758 scs_timer[1] = timer_read ();
759 register_mods(MOD_BIT(KC_RSFT));
761 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
762 unregister_mods(MOD_BIT(KC_RSFT));
763 register_code(SFTENT_KEY);
764 unregister_code(SFTENT_KEY);
767 unregister_mods(MOD_BIT(KC_RSFT));
773 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
774 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
776 #ifdef GRAVE_ESC_ALT_OVERRIDE
777 // if ALT is pressed, ESC is always sent
778 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
779 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
784 #ifdef GRAVE_ESC_CTRL_OVERRIDE
785 // if CTRL is pressed, ESC is always sent
786 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
787 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
792 #ifdef GRAVE_ESC_GUI_OVERRIDE
793 // if GUI is pressed, ESC is always sent
794 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
799 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
800 // if SHIFT is pressed, ESC is always sent
801 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
806 if (record->event.pressed) {
807 grave_esc_was_shifted = shifted;
808 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
811 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
814 send_keyboard_report();
818 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
820 if (record->event.pressed)
827 shift_interrupted[0] = true;
828 shift_interrupted[1] = true;
833 return process_action_kb(record);
836 __attribute__ ((weak))
837 const bool ascii_to_shift_lut[0x80] PROGMEM = {
838 0, 0, 0, 0, 0, 0, 0, 0,
839 0, 0, 0, 0, 0, 0, 0, 0,
840 0, 0, 0, 0, 0, 0, 0, 0,
841 0, 0, 0, 0, 0, 0, 0, 0,
842 0, 1, 1, 1, 1, 1, 1, 0,
843 1, 1, 1, 1, 0, 0, 0, 0,
844 0, 0, 0, 0, 0, 0, 0, 0,
845 0, 0, 1, 0, 1, 0, 1, 1,
846 1, 1, 1, 1, 1, 1, 1, 1,
847 1, 1, 1, 1, 1, 1, 1, 1,
848 1, 1, 1, 1, 1, 1, 1, 1,
849 1, 1, 1, 0, 0, 0, 1, 1,
850 0, 0, 0, 0, 0, 0, 0, 0,
851 0, 0, 0, 0, 0, 0, 0, 0,
852 0, 0, 0, 0, 0, 0, 0, 0,
853 0, 0, 0, 1, 1, 1, 1, 0
856 __attribute__ ((weak))
857 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
858 0, 0, 0, 0, 0, 0, 0, 0,
859 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
860 0, 0, 0, 0, 0, 0, 0, 0,
861 0, 0, 0, KC_ESC, 0, 0, 0, 0,
862 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
863 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
864 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
865 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
866 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
867 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
868 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
869 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
870 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
871 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
872 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
873 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
876 void send_string(const char *str) {
877 send_string_with_delay(str, 0);
880 void send_string_P(const char *str) {
881 send_string_with_delay_P(str, 0);
884 void send_string_with_delay(const char *str, uint8_t interval) {
886 char ascii_code = *str;
887 if (!ascii_code) break;
888 if (ascii_code == 1) {
890 uint8_t keycode = *(++str);
891 register_code(keycode);
892 unregister_code(keycode);
893 } else if (ascii_code == 2) {
895 uint8_t keycode = *(++str);
896 register_code(keycode);
897 } else if (ascii_code == 3) {
899 uint8_t keycode = *(++str);
900 unregister_code(keycode);
902 send_char(ascii_code);
906 { uint8_t ms = interval; while (ms--) wait_ms(1); }
910 void send_string_with_delay_P(const char *str, uint8_t interval) {
912 char ascii_code = pgm_read_byte(str);
913 if (!ascii_code) break;
914 if (ascii_code == 1) {
916 uint8_t keycode = pgm_read_byte(++str);
917 register_code(keycode);
918 unregister_code(keycode);
919 } else if (ascii_code == 2) {
921 uint8_t keycode = pgm_read_byte(++str);
922 register_code(keycode);
923 } else if (ascii_code == 3) {
925 uint8_t keycode = pgm_read_byte(++str);
926 unregister_code(keycode);
928 send_char(ascii_code);
932 { uint8_t ms = interval; while (ms--) wait_ms(1); }
936 void send_char(char ascii_code) {
938 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
939 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
940 register_code(KC_LSFT);
941 register_code(keycode);
942 unregister_code(keycode);
943 unregister_code(KC_LSFT);
945 register_code(keycode);
946 unregister_code(keycode);
950 void set_single_persistent_default_layer(uint8_t default_layer) {
951 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
952 PLAY_SONG(default_layer_songs[default_layer]);
954 eeconfig_update_default_layer(1U<<default_layer);
955 default_layer_set(1U<<default_layer);
958 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
959 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
960 uint32_t mask3 = 1UL << layer3;
961 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
964 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
965 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
968 void tap_random_base64(void) {
969 #if defined(__AVR_ATmega32U4__)
970 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
972 uint8_t key = rand() % 64;
976 register_code(KC_LSFT);
977 register_code(key + KC_A);
978 unregister_code(key + KC_A);
979 unregister_code(KC_LSFT);
982 register_code(key - 26 + KC_A);
983 unregister_code(key - 26 + KC_A);
987 unregister_code(KC_0);
990 register_code(key - 53 + KC_1);
991 unregister_code(key - 53 + KC_1);
994 register_code(KC_LSFT);
995 register_code(KC_EQL);
996 unregister_code(KC_EQL);
997 unregister_code(KC_LSFT);
1000 register_code(KC_SLSH);
1001 unregister_code(KC_SLSH);
1006 __attribute__((weak))
1007 void bootmagic_lite(void) {
1008 // The lite version of TMK's bootmagic based on Wilba.
1009 // 100% less potential for accidentally making the
1010 // keyboard do stupid things.
1012 // We need multiple scans because debouncing can't be turned off.
1014 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
1015 wait_ms(DEBOUNCING_DELAY * 2);
1016 #elif defined(DEBOUNCE) && DEBOUNCE > 0
1017 wait_ms(DEBOUNCE * 2);
1023 // If the Esc and space bar are held down on power up,
1024 // reset the EEPROM valid state and jump to bootloader.
1025 // Assumes Esc is at [0,0].
1026 // This isn't very generalized, but we need something that doesn't
1027 // rely on user's keymaps in firmware or EEPROM.
1028 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
1030 // Jump to bootloader.
1035 void matrix_init_quantum() {
1036 #ifdef BOOTMAGIC_LITE
1039 if (!eeconfig_is_enabled()) {
1042 #ifdef BACKLIGHT_ENABLE
1043 #ifdef LED_MATRIX_ENABLE
1046 backlight_init_ports();
1052 #ifdef RGB_MATRIX_ENABLE
1055 #ifdef ENCODER_ENABLE
1058 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1059 unicode_input_mode_init();
1061 #ifdef HAPTIC_ENABLE
1067 uint8_t rgb_matrix_task_counter = 0;
1069 #ifndef RGB_MATRIX_SKIP_FRAMES
1070 #define RGB_MATRIX_SKIP_FRAMES 1
1073 void matrix_scan_quantum() {
1074 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1075 matrix_scan_music();
1078 #ifdef TAP_DANCE_ENABLE
1079 matrix_scan_tap_dance();
1083 matrix_scan_combo();
1086 #if defined(BACKLIGHT_ENABLE)
1087 #if defined(LED_MATRIX_ENABLE)
1089 #elif defined(BACKLIGHT_PIN)
1094 #ifdef RGB_MATRIX_ENABLE
1096 if (rgb_matrix_task_counter == 0) {
1097 rgb_matrix_update_pwm_buffers();
1099 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1102 #ifdef ENCODER_ENABLE
1106 #ifdef HAPTIC_ENABLE
1112 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1114 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1116 // depending on the pin, we use a different output compare unit
1117 #if BACKLIGHT_PIN == B7
1118 # define TCCRxA TCCR1A
1119 # define TCCRxB TCCR1B
1120 # define COMxx1 COM1C1
1121 # define OCRxx OCR1C
1123 #elif BACKLIGHT_PIN == B6
1124 # define TCCRxA TCCR1A
1125 # define TCCRxB TCCR1B
1126 # define COMxx1 COM1B1
1127 # define OCRxx OCR1B
1129 #elif BACKLIGHT_PIN == B5
1130 # define TCCRxA TCCR1A
1131 # define TCCRxB TCCR1B
1132 # define COMxx1 COM1A1
1133 # define OCRxx OCR1A
1135 #elif BACKLIGHT_PIN == C6
1136 # define TCCRxA TCCR3A
1137 # define TCCRxB TCCR3B
1138 # define COMxx1 COM1A1
1139 # define OCRxx OCR3A
1142 # define NO_HARDWARE_PWM
1145 #ifndef BACKLIGHT_ON_STATE
1146 #define BACKLIGHT_ON_STATE 0
1149 #ifdef NO_HARDWARE_PWM // pwm through software
1151 __attribute__ ((weak))
1152 void backlight_init_ports(void)
1154 // Setup backlight pin as output and output to on state.
1156 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1157 #if BACKLIGHT_ON_STATE == 0
1159 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1162 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1166 __attribute__ ((weak))
1167 void backlight_set(uint8_t level) {}
1169 uint8_t backlight_tick = 0;
1171 #ifndef BACKLIGHT_CUSTOM_DRIVER
1172 void backlight_task(void) {
1173 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1174 #if BACKLIGHT_ON_STATE == 0
1176 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1179 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1182 #if BACKLIGHT_ON_STATE == 0
1184 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1187 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1190 backlight_tick = (backlight_tick + 1) % 16;
1194 #ifdef BACKLIGHT_BREATHING
1195 #ifndef BACKLIGHT_CUSTOM_DRIVER
1196 #error "Backlight breathing only available with hardware PWM. Please disable."
1200 #else // pwm through timer
1202 #define TIMER_TOP 0xFFFFU
1204 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1205 static uint16_t cie_lightness(uint16_t v) {
1206 if (v <= 5243) // if below 8% of max
1207 return v / 9; // same as dividing by 900%
1209 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1210 // to get a useful result with integer division, we shift left in the expression above
1211 // and revert what we've done again after squaring.
1213 if (y > 0xFFFFUL) // prevent overflow
1216 return (uint16_t) y;
1220 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1221 static inline void set_pwm(uint16_t val) {
1225 #ifndef BACKLIGHT_CUSTOM_DRIVER
1226 __attribute__ ((weak))
1227 void backlight_set(uint8_t level) {
1228 if (level > BACKLIGHT_LEVELS)
1229 level = BACKLIGHT_LEVELS;
1232 // Turn off PWM control on backlight pin
1233 TCCRxA &= ~(_BV(COMxx1));
1235 // Turn on PWM control of backlight pin
1236 TCCRxA |= _BV(COMxx1);
1238 // Set the brightness
1239 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1242 void backlight_task(void) {}
1243 #endif // BACKLIGHT_CUSTOM_DRIVER
1245 #ifdef BACKLIGHT_BREATHING
1247 #define BREATHING_NO_HALT 0
1248 #define BREATHING_HALT_OFF 1
1249 #define BREATHING_HALT_ON 2
1250 #define BREATHING_STEPS 128
1252 static uint8_t breathing_period = BREATHING_PERIOD;
1253 static uint8_t breathing_halt = BREATHING_NO_HALT;
1254 static uint16_t breathing_counter = 0;
1256 bool is_breathing(void) {
1257 return !!(TIMSK1 & _BV(TOIE1));
1260 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1261 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1262 #define breathing_min() do {breathing_counter = 0;} while (0)
1263 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1265 void breathing_enable(void)
1267 breathing_counter = 0;
1268 breathing_halt = BREATHING_NO_HALT;
1269 breathing_interrupt_enable();
1272 void breathing_pulse(void)
1274 if (get_backlight_level() == 0)
1278 breathing_halt = BREATHING_HALT_ON;
1279 breathing_interrupt_enable();
1282 void breathing_disable(void)
1284 breathing_interrupt_disable();
1285 // Restore backlight level
1286 backlight_set(get_backlight_level());
1289 void breathing_self_disable(void)
1291 if (get_backlight_level() == 0)
1292 breathing_halt = BREATHING_HALT_OFF;
1294 breathing_halt = BREATHING_HALT_ON;
1297 void breathing_toggle(void) {
1299 breathing_disable();
1304 void breathing_period_set(uint8_t value)
1308 breathing_period = value;
1311 void breathing_period_default(void) {
1312 breathing_period_set(BREATHING_PERIOD);
1315 void breathing_period_inc(void)
1317 breathing_period_set(breathing_period+1);
1320 void breathing_period_dec(void)
1322 breathing_period_set(breathing_period-1);
1325 /* To generate breathing curve in python:
1326 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1328 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};
1330 // Use this before the cie_lightness function.
1331 static inline uint16_t scale_backlight(uint16_t v) {
1332 return v / BACKLIGHT_LEVELS * get_backlight_level();
1335 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1336 * about 244 times per second.
1338 ISR(TIMER1_OVF_vect)
1340 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1341 // resetting after one period to prevent ugly reset at overflow.
1342 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1343 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1345 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1346 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1348 breathing_interrupt_disable();
1351 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1354 #endif // BACKLIGHT_BREATHING
1356 __attribute__ ((weak))
1357 void backlight_init_ports(void)
1359 // Setup backlight pin as output and output to on state.
1361 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1362 #if BACKLIGHT_ON_STATE == 0
1364 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1367 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1369 // I could write a wall of text here to explain... but TL;DW
1370 // Go read the ATmega32u4 datasheet.
1371 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1373 // Pin PB7 = OCR1C (Timer 1, Channel C)
1374 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1375 // (i.e. start high, go low when counter matches.)
1376 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1377 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1381 "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 [..]."
1382 "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)."
1384 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1385 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1386 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1390 #ifdef BACKLIGHT_BREATHING
1395 #endif // NO_HARDWARE_PWM
1399 __attribute__ ((weak))
1400 void backlight_init_ports(void) {}
1402 __attribute__ ((weak))
1403 void backlight_set(uint8_t level) {}
1407 #ifdef HD44780_ENABLED
1408 #include "hd44780.h"
1412 // Functions for spitting out values
1415 void send_dword(uint32_t number) { // this might not actually work
1416 uint16_t word = (number >> 16);
1418 send_word(number & 0xFFFFUL);
1421 void send_word(uint16_t number) {
1422 uint8_t byte = number >> 8;
1424 send_byte(number & 0xFF);
1427 void send_byte(uint8_t number) {
1428 uint8_t nibble = number >> 4;
1429 send_nibble(nibble);
1430 send_nibble(number & 0xF);
1433 void send_nibble(uint8_t number) {
1436 register_code(KC_0);
1437 unregister_code(KC_0);
1440 register_code(KC_1 + (number - 1));
1441 unregister_code(KC_1 + (number - 1));
1444 register_code(KC_A + (number - 0xA));
1445 unregister_code(KC_A + (number - 0xA));
1451 __attribute__((weak))
1452 uint16_t hex_to_keycode(uint8_t hex)
1457 } else if (hex < 0xA) {
1458 return KC_1 + (hex - 0x1);
1460 return KC_A + (hex - 0xA);
1464 void api_send_unicode(uint32_t unicode) {
1467 dword_to_bytes(unicode, chunk);
1468 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1472 __attribute__ ((weak))
1473 void led_set_user(uint8_t usb_led) {
1477 __attribute__ ((weak))
1478 void led_set_kb(uint8_t usb_led) {
1479 led_set_user(usb_led);
1482 __attribute__ ((weak))
1483 void led_init_ports(void)
1488 __attribute__ ((weak))
1489 void led_set(uint8_t usb_led)
1494 // // Using PE6 Caps Lock LED
1495 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1505 // PORTE &= ~(1<<6);
1508 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1509 // Use backlight as Caps Lock indicator
1510 uint8_t bl_toggle_lvl = 0;
1512 if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1513 // Turning Caps Lock ON and backlight is disabled in config
1514 // Toggling backlight to the brightest level
1515 bl_toggle_lvl = BACKLIGHT_LEVELS;
1516 } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1517 // Turning Caps Lock OFF and backlight is enabled in config
1518 // Toggling backlight and restoring config level
1519 bl_toggle_lvl = backlight_config.level;
1522 // Set level without modify backlight_config to keep ability to restore state
1523 backlight_set(bl_toggle_lvl);
1526 led_set_kb(usb_led);
1530 //------------------------------------------------------------------------------
1531 // Override these functions in your keymap file to play different tunes on
1532 // different events such as startup and bootloader jump
1534 __attribute__ ((weak))
1535 void startup_user() {}
1537 __attribute__ ((weak))
1538 void shutdown_user() {}
1540 //------------------------------------------------------------------------------