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"
57 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
60 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
63 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
65 float goodbye_song[][2] = GOODBYE_SONG;
66 float ag_norm_song[][2] = AG_NORM_SONG;
67 float ag_swap_song[][2] = AG_SWAP_SONG;
68 #ifdef DEFAULT_LAYER_SONGS
69 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
73 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
75 case QK_MODS ... QK_MODS_MAX:
90 if (code < QK_RMODS_MIN) return;
102 static inline void qk_register_weak_mods(uint8_t kc) {
103 add_weak_mods(MOD_BIT(kc));
104 send_keyboard_report();
107 static inline void qk_unregister_weak_mods(uint8_t kc) {
108 del_weak_mods(MOD_BIT(kc));
109 send_keyboard_report();
112 static inline void qk_register_mods(uint8_t kc) {
113 add_weak_mods(MOD_BIT(kc));
114 send_keyboard_report();
117 static inline void qk_unregister_mods(uint8_t kc) {
118 del_weak_mods(MOD_BIT(kc));
119 send_keyboard_report();
122 void register_code16 (uint16_t code) {
123 if (IS_MOD(code) || code == KC_NO) {
124 do_code16 (code, qk_register_mods);
126 do_code16 (code, qk_register_weak_mods);
128 register_code (code);
131 void unregister_code16 (uint16_t code) {
132 unregister_code (code);
133 if (IS_MOD(code) || code == KC_NO) {
134 do_code16 (code, qk_unregister_mods);
136 do_code16 (code, qk_unregister_weak_mods);
140 void tap_code16(uint16_t code) {
141 register_code16(code);
142 #if TAP_CODE_DELAY > 0
143 wait_ms(TAP_CODE_DELAY);
145 unregister_code16(code);
148 __attribute__ ((weak))
149 bool process_action_kb(keyrecord_t *record) {
153 __attribute__ ((weak))
154 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
155 return process_record_user(keycode, record);
158 __attribute__ ((weak))
159 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
163 void reset_keyboard(void) {
165 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
166 process_midi_all_notes_off();
169 #ifndef NO_MUSIC_MODE
170 music_all_notes_off();
172 uint16_t timer_start = timer_read();
173 PLAY_SONG(goodbye_song);
175 while(timer_elapsed(timer_start) < 250)
182 // this is also done later in bootloader.c - not sure if it's neccesary here
183 #ifdef BOOTLOADER_CATERINA
184 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
189 // Shift / paren setup
192 #define LSPO_KEY KC_9
195 #define RSPC_KEY KC_0
199 #define LSPO_MOD KC_LSFT
202 #define RSPC_MOD KC_RSFT
205 // Shift / Enter setup
207 #define SFTENT_KEY KC_ENT
210 static bool shift_interrupted[2] = {0, 0};
211 static uint16_t scs_timer[2] = {0, 0};
213 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
214 * Used to ensure that the correct keycode is released if the key is released.
216 static bool grave_esc_was_shifted = false;
218 bool process_record_quantum(keyrecord_t *record) {
220 /* This gets the keycode from the key pressed */
221 keypos_t key = record->event.key;
224 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
225 /* TODO: Use store_or_get_action() or a similar function. */
226 if (!disable_action_cache) {
229 if (record->event.pressed) {
230 layer = layer_switch_get_layer(key);
231 update_source_layers_cache(key, layer);
233 layer = read_source_layers_cache(key);
235 keycode = keymap_key_to_keycode(layer, key);
238 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
240 // This is how you use actions here
241 // if (keycode == KC_LEAD) {
243 // action.code = ACTION_DEFAULT_LAYER_SET(0);
244 // process_action(record, action);
248 #ifdef TAP_DANCE_ENABLE
249 preprocess_tap_dance(keycode, record);
253 #if defined(KEY_LOCK_ENABLE)
254 // Must run first to be able to mask key_up events.
255 process_key_lock(&keycode, record) &&
257 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
258 process_clicky(keycode, record) &&
259 #endif //AUDIO_CLICKY
260 process_record_kb(keycode, record) &&
261 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
262 process_rgb_matrix(keycode, record) &&
264 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
265 process_midi(keycode, record) &&
268 process_audio(keycode, record) &&
271 process_steno(keycode, record) &&
273 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
274 process_music(keycode, record) &&
276 #ifdef TAP_DANCE_ENABLE
277 process_tap_dance(keycode, record) &&
279 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
280 process_unicode_common(keycode, record) &&
283 process_leader(keycode, record) &&
286 process_combo(keycode, record) &&
288 #ifdef PRINTING_ENABLE
289 process_printer(keycode, record) &&
291 #ifdef AUTO_SHIFT_ENABLE
292 process_auto_shift(keycode, record) &&
294 #ifdef TERMINAL_ENABLE
295 process_terminal(keycode, record) &&
301 // Shift / paren setup
305 if (record->event.pressed) {
310 if (record->event.pressed) {
312 print("DEBUG: enabled.\n");
316 if (record->event.pressed) {
320 #ifdef FAUXCLICKY_ENABLE
322 if (record->event.pressed) {
327 if (record->event.pressed) {
332 if (record->event.pressed) {
337 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
339 // Split keyboards need to trigger on key-up for edge-case issue
340 #ifndef SPLIT_KEYBOARD
341 if (record->event.pressed) {
343 if (!record->event.pressed) {
346 #ifdef SPLIT_KEYBOARD
351 case RGB_MODE_FORWARD:
352 if (record->event.pressed) {
353 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
355 rgblight_step_reverse();
360 #ifdef SPLIT_KEYBOARD
365 case RGB_MODE_REVERSE:
366 if (record->event.pressed) {
367 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
372 rgblight_step_reverse();
374 #ifdef SPLIT_KEYBOARD
380 // Split keyboards need to trigger on key-up for edge-case issue
381 #ifndef SPLIT_KEYBOARD
382 if (record->event.pressed) {
384 if (!record->event.pressed) {
386 rgblight_increase_hue();
387 #ifdef SPLIT_KEYBOARD
393 // Split keyboards need to trigger on key-up for edge-case issue
394 #ifndef SPLIT_KEYBOARD
395 if (record->event.pressed) {
397 if (!record->event.pressed) {
399 rgblight_decrease_hue();
400 #ifdef SPLIT_KEYBOARD
406 // Split keyboards need to trigger on key-up for edge-case issue
407 #ifndef SPLIT_KEYBOARD
408 if (record->event.pressed) {
410 if (!record->event.pressed) {
412 rgblight_increase_sat();
413 #ifdef SPLIT_KEYBOARD
419 // Split keyboards need to trigger on key-up for edge-case issue
420 #ifndef SPLIT_KEYBOARD
421 if (record->event.pressed) {
423 if (!record->event.pressed) {
425 rgblight_decrease_sat();
426 #ifdef SPLIT_KEYBOARD
432 // Split keyboards need to trigger on key-up for edge-case issue
433 #ifndef SPLIT_KEYBOARD
434 if (record->event.pressed) {
436 if (!record->event.pressed) {
438 rgblight_increase_val();
439 #ifdef SPLIT_KEYBOARD
445 // Split keyboards need to trigger on key-up for edge-case issue
446 #ifndef SPLIT_KEYBOARD
447 if (record->event.pressed) {
449 if (!record->event.pressed) {
451 rgblight_decrease_val();
452 #ifdef SPLIT_KEYBOARD
458 if (record->event.pressed) {
459 rgblight_increase_speed();
463 if (record->event.pressed) {
464 rgblight_decrease_speed();
468 if (record->event.pressed) {
469 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
470 #ifdef SPLIT_KEYBOARD
475 case RGB_MODE_BREATHE:
476 #ifdef RGBLIGHT_EFFECT_BREATHING
477 if (record->event.pressed) {
478 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
479 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
482 rgblight_mode(RGBLIGHT_MODE_BREATHING);
487 case RGB_MODE_RAINBOW:
488 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
489 if (record->event.pressed) {
490 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
491 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
494 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
500 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
501 if (record->event.pressed) {
502 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
503 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
506 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
512 #ifdef RGBLIGHT_EFFECT_SNAKE
513 if (record->event.pressed) {
514 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
515 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
518 rgblight_mode(RGBLIGHT_MODE_SNAKE);
523 case RGB_MODE_KNIGHT:
524 #ifdef RGBLIGHT_EFFECT_KNIGHT
525 if (record->event.pressed) {
526 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
527 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
530 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
536 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
537 if (record->event.pressed) {
538 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
542 case RGB_MODE_GRADIENT:
543 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
544 if (record->event.pressed) {
545 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
546 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
549 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
554 case RGB_MODE_RGBTEST:
555 #ifdef RGBLIGHT_EFFECT_RGB_TEST
556 if (record->event.pressed) {
557 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
561 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
564 if (record->event.pressed) {
565 set_output(OUTPUT_AUTO);
569 if (record->event.pressed) {
570 set_output(OUTPUT_USB);
573 #ifdef BLUETOOTH_ENABLE
575 if (record->event.pressed) {
576 set_output(OUTPUT_BLUETOOTH);
581 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
582 if (record->event.pressed) {
583 // MAGIC actions (BOOTMAGIC without the boot)
584 if (!eeconfig_is_enabled()) {
588 keymap_config.raw = eeconfig_read_keymap();
591 case MAGIC_SWAP_CONTROL_CAPSLOCK:
592 keymap_config.swap_control_capslock = true;
594 case MAGIC_CAPSLOCK_TO_CONTROL:
595 keymap_config.capslock_to_control = true;
597 case MAGIC_SWAP_LALT_LGUI:
598 keymap_config.swap_lalt_lgui = true;
600 case MAGIC_SWAP_RALT_RGUI:
601 keymap_config.swap_ralt_rgui = true;
604 keymap_config.no_gui = true;
606 case MAGIC_SWAP_GRAVE_ESC:
607 keymap_config.swap_grave_esc = true;
609 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
610 keymap_config.swap_backslash_backspace = true;
612 case MAGIC_HOST_NKRO:
613 keymap_config.nkro = true;
615 case MAGIC_SWAP_ALT_GUI:
616 keymap_config.swap_lalt_lgui = true;
617 keymap_config.swap_ralt_rgui = true;
619 PLAY_SONG(ag_swap_song);
622 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
623 keymap_config.swap_control_capslock = false;
625 case MAGIC_UNCAPSLOCK_TO_CONTROL:
626 keymap_config.capslock_to_control = false;
628 case MAGIC_UNSWAP_LALT_LGUI:
629 keymap_config.swap_lalt_lgui = false;
631 case MAGIC_UNSWAP_RALT_RGUI:
632 keymap_config.swap_ralt_rgui = false;
635 keymap_config.no_gui = false;
637 case MAGIC_UNSWAP_GRAVE_ESC:
638 keymap_config.swap_grave_esc = false;
640 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
641 keymap_config.swap_backslash_backspace = false;
643 case MAGIC_UNHOST_NKRO:
644 keymap_config.nkro = false;
646 case MAGIC_UNSWAP_ALT_GUI:
647 keymap_config.swap_lalt_lgui = false;
648 keymap_config.swap_ralt_rgui = false;
650 PLAY_SONG(ag_norm_song);
653 case MAGIC_TOGGLE_ALT_GUI:
654 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
655 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
657 if (keymap_config.swap_ralt_rgui) {
658 PLAY_SONG(ag_swap_song);
660 PLAY_SONG(ag_norm_song);
664 case MAGIC_TOGGLE_NKRO:
665 keymap_config.nkro = !keymap_config.nkro;
670 eeconfig_update_keymap(keymap_config.raw);
671 clear_keyboard(); // clear to prevent stuck keys
677 if (record->event.pressed) {
678 shift_interrupted[0] = false;
679 scs_timer[0] = timer_read ();
680 register_mods(MOD_BIT(KC_LSFT));
683 #ifdef DISABLE_SPACE_CADET_ROLLOVER
684 if (get_mods() & MOD_BIT(RSPC_MOD)) {
685 shift_interrupted[0] = true;
686 shift_interrupted[1] = true;
689 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
690 #ifdef DISABLE_SPACE_CADET_MODIFIER
691 unregister_mods(MOD_BIT(KC_LSFT));
693 if( LSPO_MOD != KC_LSFT ){
694 unregister_mods(MOD_BIT(KC_LSFT));
695 register_mods(MOD_BIT(LSPO_MOD));
698 register_code(LSPO_KEY);
699 unregister_code(LSPO_KEY);
700 #ifndef DISABLE_SPACE_CADET_MODIFIER
701 if( LSPO_MOD != KC_LSFT ){
702 unregister_mods(MOD_BIT(LSPO_MOD));
706 unregister_mods(MOD_BIT(KC_LSFT));
712 if (record->event.pressed) {
713 shift_interrupted[1] = false;
714 scs_timer[1] = timer_read ();
715 register_mods(MOD_BIT(KC_RSFT));
718 #ifdef DISABLE_SPACE_CADET_ROLLOVER
719 if (get_mods() & MOD_BIT(LSPO_MOD)) {
720 shift_interrupted[0] = true;
721 shift_interrupted[1] = true;
724 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
725 #ifdef DISABLE_SPACE_CADET_MODIFIER
726 unregister_mods(MOD_BIT(KC_RSFT));
728 if( RSPC_MOD != KC_RSFT ){
729 unregister_mods(MOD_BIT(KC_RSFT));
730 register_mods(MOD_BIT(RSPC_MOD));
733 register_code(RSPC_KEY);
734 unregister_code(RSPC_KEY);
735 #ifndef DISABLE_SPACE_CADET_MODIFIER
736 if ( RSPC_MOD != KC_RSFT ){
737 unregister_mods(MOD_BIT(RSPC_MOD));
741 unregister_mods(MOD_BIT(KC_RSFT));
747 if (record->event.pressed) {
748 shift_interrupted[1] = false;
749 scs_timer[1] = timer_read ();
750 register_mods(MOD_BIT(KC_RSFT));
752 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
753 unregister_mods(MOD_BIT(KC_RSFT));
754 register_code(SFTENT_KEY);
755 unregister_code(SFTENT_KEY);
758 unregister_mods(MOD_BIT(KC_RSFT));
764 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
765 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
767 #ifdef GRAVE_ESC_ALT_OVERRIDE
768 // if ALT is pressed, ESC is always sent
769 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
770 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
775 #ifdef GRAVE_ESC_CTRL_OVERRIDE
776 // if CTRL is pressed, ESC is always sent
777 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
778 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
783 #ifdef GRAVE_ESC_GUI_OVERRIDE
784 // if GUI is pressed, ESC is always sent
785 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
790 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
791 // if SHIFT is pressed, ESC is always sent
792 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
797 if (record->event.pressed) {
798 grave_esc_was_shifted = shifted;
799 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
802 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
805 send_keyboard_report();
809 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
811 if (record->event.pressed)
818 shift_interrupted[0] = true;
819 shift_interrupted[1] = true;
824 return process_action_kb(record);
827 __attribute__ ((weak))
828 const bool ascii_to_shift_lut[0x80] PROGMEM = {
829 0, 0, 0, 0, 0, 0, 0, 0,
830 0, 0, 0, 0, 0, 0, 0, 0,
831 0, 0, 0, 0, 0, 0, 0, 0,
832 0, 0, 0, 0, 0, 0, 0, 0,
833 0, 1, 1, 1, 1, 1, 1, 0,
834 1, 1, 1, 1, 0, 0, 0, 0,
835 0, 0, 0, 0, 0, 0, 0, 0,
836 0, 0, 1, 0, 1, 0, 1, 1,
837 1, 1, 1, 1, 1, 1, 1, 1,
838 1, 1, 1, 1, 1, 1, 1, 1,
839 1, 1, 1, 1, 1, 1, 1, 1,
840 1, 1, 1, 0, 0, 0, 1, 1,
841 0, 0, 0, 0, 0, 0, 0, 0,
842 0, 0, 0, 0, 0, 0, 0, 0,
843 0, 0, 0, 0, 0, 0, 0, 0,
844 0, 0, 0, 1, 1, 1, 1, 0
847 __attribute__ ((weak))
848 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
849 0, 0, 0, 0, 0, 0, 0, 0,
850 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
851 0, 0, 0, 0, 0, 0, 0, 0,
852 0, 0, 0, KC_ESC, 0, 0, 0, 0,
853 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
854 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
855 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
856 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
857 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
858 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
859 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
860 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
861 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
862 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
863 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
864 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
867 void send_string(const char *str) {
868 send_string_with_delay(str, 0);
871 void send_string_P(const char *str) {
872 send_string_with_delay_P(str, 0);
875 void send_string_with_delay(const char *str, uint8_t interval) {
877 char ascii_code = *str;
878 if (!ascii_code) break;
879 if (ascii_code == 1) {
881 uint8_t keycode = *(++str);
882 register_code(keycode);
883 unregister_code(keycode);
884 } else if (ascii_code == 2) {
886 uint8_t keycode = *(++str);
887 register_code(keycode);
888 } else if (ascii_code == 3) {
890 uint8_t keycode = *(++str);
891 unregister_code(keycode);
893 send_char(ascii_code);
897 { uint8_t ms = interval; while (ms--) wait_ms(1); }
901 void send_string_with_delay_P(const char *str, uint8_t interval) {
903 char ascii_code = pgm_read_byte(str);
904 if (!ascii_code) break;
905 if (ascii_code == 1) {
907 uint8_t keycode = pgm_read_byte(++str);
908 register_code(keycode);
909 unregister_code(keycode);
910 } else if (ascii_code == 2) {
912 uint8_t keycode = pgm_read_byte(++str);
913 register_code(keycode);
914 } else if (ascii_code == 3) {
916 uint8_t keycode = pgm_read_byte(++str);
917 unregister_code(keycode);
919 send_char(ascii_code);
923 { uint8_t ms = interval; while (ms--) wait_ms(1); }
927 void send_char(char ascii_code) {
929 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
930 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
931 register_code(KC_LSFT);
932 register_code(keycode);
933 unregister_code(keycode);
934 unregister_code(KC_LSFT);
936 register_code(keycode);
937 unregister_code(keycode);
941 void set_single_persistent_default_layer(uint8_t default_layer) {
942 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
943 PLAY_SONG(default_layer_songs[default_layer]);
945 eeconfig_update_default_layer(1U<<default_layer);
946 default_layer_set(1U<<default_layer);
949 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
950 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
951 uint32_t mask3 = 1UL << layer3;
952 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
955 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
956 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
959 void tap_random_base64(void) {
960 #if defined(__AVR_ATmega32U4__)
961 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
963 uint8_t key = rand() % 64;
967 register_code(KC_LSFT);
968 register_code(key + KC_A);
969 unregister_code(key + KC_A);
970 unregister_code(KC_LSFT);
973 register_code(key - 26 + KC_A);
974 unregister_code(key - 26 + KC_A);
978 unregister_code(KC_0);
981 register_code(key - 53 + KC_1);
982 unregister_code(key - 53 + KC_1);
985 register_code(KC_LSFT);
986 register_code(KC_EQL);
987 unregister_code(KC_EQL);
988 unregister_code(KC_LSFT);
991 register_code(KC_SLSH);
992 unregister_code(KC_SLSH);
997 __attribute__((weak))
998 void bootmagic_lite(void) {
999 // The lite version of TMK's bootmagic based on Wilba.
1000 // 100% less potential for accidentally making the
1001 // keyboard do stupid things.
1003 // We need multiple scans because debouncing can't be turned off.
1005 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
1006 wait_ms(DEBOUNCING_DELAY * 2);
1007 #elif defined(DEBOUNCE) && DEBOUNCE > 0
1008 wait_ms(DEBOUNCE * 2);
1014 // If the Esc and space bar are held down on power up,
1015 // reset the EEPROM valid state and jump to bootloader.
1016 // Assumes Esc is at [0,0].
1017 // This isn't very generalized, but we need something that doesn't
1018 // rely on user's keymaps in firmware or EEPROM.
1019 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
1021 // Jump to bootloader.
1026 void matrix_init_quantum() {
1027 #ifdef BOOTMAGIC_LITE
1030 if (!eeconfig_is_enabled()) {
1033 #ifdef BACKLIGHT_ENABLE
1034 #ifdef LED_MATRIX_ENABLE
1037 backlight_init_ports();
1043 #ifdef RGB_MATRIX_ENABLE
1046 #ifdef ENCODER_ENABLE
1049 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1050 unicode_input_mode_init();
1055 uint8_t rgb_matrix_task_counter = 0;
1057 #ifndef RGB_MATRIX_SKIP_FRAMES
1058 #define RGB_MATRIX_SKIP_FRAMES 1
1061 void matrix_scan_quantum() {
1062 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1063 matrix_scan_music();
1066 #ifdef TAP_DANCE_ENABLE
1067 matrix_scan_tap_dance();
1071 matrix_scan_combo();
1074 #if defined(BACKLIGHT_ENABLE)
1075 #if defined(LED_MATRIX_ENABLE)
1077 #elif defined(BACKLIGHT_PIN)
1082 #ifdef RGB_MATRIX_ENABLE
1084 if (rgb_matrix_task_counter == 0) {
1085 rgb_matrix_update_pwm_buffers();
1087 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1090 #ifdef ENCODER_ENABLE
1096 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1098 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1100 // depending on the pin, we use a different output compare unit
1101 #if BACKLIGHT_PIN == B7
1102 # define TCCRxA TCCR1A
1103 # define TCCRxB TCCR1B
1104 # define COMxx1 COM1C1
1105 # define OCRxx OCR1C
1107 #elif BACKLIGHT_PIN == B6
1108 # define TCCRxA TCCR1A
1109 # define TCCRxB TCCR1B
1110 # define COMxx1 COM1B1
1111 # define OCRxx OCR1B
1113 #elif BACKLIGHT_PIN == B5
1114 # define TCCRxA TCCR1A
1115 # define TCCRxB TCCR1B
1116 # define COMxx1 COM1A1
1117 # define OCRxx OCR1A
1119 #elif BACKLIGHT_PIN == C6
1120 # define TCCRxA TCCR3A
1121 # define TCCRxB TCCR3B
1122 # define COMxx1 COM1A1
1123 # define OCRxx OCR3A
1126 # define NO_HARDWARE_PWM
1129 #ifndef BACKLIGHT_ON_STATE
1130 #define BACKLIGHT_ON_STATE 0
1133 #ifdef NO_HARDWARE_PWM // pwm through software
1135 __attribute__ ((weak))
1136 void backlight_init_ports(void)
1138 // Setup backlight pin as output and output to on state.
1140 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1141 #if BACKLIGHT_ON_STATE == 0
1143 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1146 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1150 __attribute__ ((weak))
1151 void backlight_set(uint8_t level) {}
1153 uint8_t backlight_tick = 0;
1155 #ifndef BACKLIGHT_CUSTOM_DRIVER
1156 void backlight_task(void) {
1157 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1158 #if BACKLIGHT_ON_STATE == 0
1160 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1163 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1166 #if BACKLIGHT_ON_STATE == 0
1168 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1171 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1174 backlight_tick = (backlight_tick + 1) % 16;
1178 #ifdef BACKLIGHT_BREATHING
1179 #ifndef BACKLIGHT_CUSTOM_DRIVER
1180 #error "Backlight breathing only available with hardware PWM. Please disable."
1184 #else // pwm through timer
1186 #define TIMER_TOP 0xFFFFU
1188 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1189 static uint16_t cie_lightness(uint16_t v) {
1190 if (v <= 5243) // if below 8% of max
1191 return v / 9; // same as dividing by 900%
1193 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1194 // to get a useful result with integer division, we shift left in the expression above
1195 // and revert what we've done again after squaring.
1197 if (y > 0xFFFFUL) // prevent overflow
1200 return (uint16_t) y;
1204 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1205 static inline void set_pwm(uint16_t val) {
1209 #ifndef BACKLIGHT_CUSTOM_DRIVER
1210 __attribute__ ((weak))
1211 void backlight_set(uint8_t level) {
1212 if (level > BACKLIGHT_LEVELS)
1213 level = BACKLIGHT_LEVELS;
1216 // Turn off PWM control on backlight pin
1217 TCCRxA &= ~(_BV(COMxx1));
1219 // Turn on PWM control of backlight pin
1220 TCCRxA |= _BV(COMxx1);
1222 // Set the brightness
1223 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1226 void backlight_task(void) {}
1227 #endif // BACKLIGHT_CUSTOM_DRIVER
1229 #ifdef BACKLIGHT_BREATHING
1231 #define BREATHING_NO_HALT 0
1232 #define BREATHING_HALT_OFF 1
1233 #define BREATHING_HALT_ON 2
1234 #define BREATHING_STEPS 128
1236 static uint8_t breathing_period = BREATHING_PERIOD;
1237 static uint8_t breathing_halt = BREATHING_NO_HALT;
1238 static uint16_t breathing_counter = 0;
1240 bool is_breathing(void) {
1241 return !!(TIMSK1 & _BV(TOIE1));
1244 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1245 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1246 #define breathing_min() do {breathing_counter = 0;} while (0)
1247 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1249 void breathing_enable(void)
1251 breathing_counter = 0;
1252 breathing_halt = BREATHING_NO_HALT;
1253 breathing_interrupt_enable();
1256 void breathing_pulse(void)
1258 if (get_backlight_level() == 0)
1262 breathing_halt = BREATHING_HALT_ON;
1263 breathing_interrupt_enable();
1266 void breathing_disable(void)
1268 breathing_interrupt_disable();
1269 // Restore backlight level
1270 backlight_set(get_backlight_level());
1273 void breathing_self_disable(void)
1275 if (get_backlight_level() == 0)
1276 breathing_halt = BREATHING_HALT_OFF;
1278 breathing_halt = BREATHING_HALT_ON;
1281 void breathing_toggle(void) {
1283 breathing_disable();
1288 void breathing_period_set(uint8_t value)
1292 breathing_period = value;
1295 void breathing_period_default(void) {
1296 breathing_period_set(BREATHING_PERIOD);
1299 void breathing_period_inc(void)
1301 breathing_period_set(breathing_period+1);
1304 void breathing_period_dec(void)
1306 breathing_period_set(breathing_period-1);
1309 /* To generate breathing curve in python:
1310 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1312 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};
1314 // Use this before the cie_lightness function.
1315 static inline uint16_t scale_backlight(uint16_t v) {
1316 return v / BACKLIGHT_LEVELS * get_backlight_level();
1319 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1320 * about 244 times per second.
1322 ISR(TIMER1_OVF_vect)
1324 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1325 // resetting after one period to prevent ugly reset at overflow.
1326 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1327 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1329 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1330 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1332 breathing_interrupt_disable();
1335 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1338 #endif // BACKLIGHT_BREATHING
1340 __attribute__ ((weak))
1341 void backlight_init_ports(void)
1343 // Setup backlight pin as output and output to on state.
1345 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1346 #if BACKLIGHT_ON_STATE == 0
1348 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1351 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1353 // I could write a wall of text here to explain... but TL;DW
1354 // Go read the ATmega32u4 datasheet.
1355 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1357 // Pin PB7 = OCR1C (Timer 1, Channel C)
1358 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1359 // (i.e. start high, go low when counter matches.)
1360 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1361 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1365 "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 [..]."
1366 "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)."
1368 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1369 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1370 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1374 #ifdef BACKLIGHT_BREATHING
1379 #endif // NO_HARDWARE_PWM
1383 __attribute__ ((weak))
1384 void backlight_init_ports(void) {}
1386 __attribute__ ((weak))
1387 void backlight_set(uint8_t level) {}
1391 #ifdef HD44780_ENABLED
1392 #include "hd44780.h"
1396 // Functions for spitting out values
1399 void send_dword(uint32_t number) { // this might not actually work
1400 uint16_t word = (number >> 16);
1402 send_word(number & 0xFFFFUL);
1405 void send_word(uint16_t number) {
1406 uint8_t byte = number >> 8;
1408 send_byte(number & 0xFF);
1411 void send_byte(uint8_t number) {
1412 uint8_t nibble = number >> 4;
1413 send_nibble(nibble);
1414 send_nibble(number & 0xF);
1417 void send_nibble(uint8_t number) {
1420 register_code(KC_0);
1421 unregister_code(KC_0);
1424 register_code(KC_1 + (number - 1));
1425 unregister_code(KC_1 + (number - 1));
1428 register_code(KC_A + (number - 0xA));
1429 unregister_code(KC_A + (number - 0xA));
1435 __attribute__((weak))
1436 uint16_t hex_to_keycode(uint8_t hex)
1441 } else if (hex < 0xA) {
1442 return KC_1 + (hex - 0x1);
1444 return KC_A + (hex - 0xA);
1448 void api_send_unicode(uint32_t unicode) {
1451 dword_to_bytes(unicode, chunk);
1452 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1456 __attribute__ ((weak))
1457 void led_set_user(uint8_t usb_led) {
1461 __attribute__ ((weak))
1462 void led_set_kb(uint8_t usb_led) {
1463 led_set_user(usb_led);
1466 __attribute__ ((weak))
1467 void led_init_ports(void)
1472 __attribute__ ((weak))
1473 void led_set(uint8_t usb_led)
1478 // // Using PE6 Caps Lock LED
1479 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1489 // PORTE &= ~(1<<6);
1492 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1493 // Use backlight as Caps Lock indicator
1494 uint8_t bl_toggle_lvl = 0;
1496 if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1497 // Turning Caps Lock ON and backlight is disabled in config
1498 // Toggling backlight to the brightest level
1499 bl_toggle_lvl = BACKLIGHT_LEVELS;
1500 } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1501 // Turning Caps Lock OFF and backlight is enabled in config
1502 // Toggling backlight and restoring config level
1503 bl_toggle_lvl = backlight_config.level;
1506 // Set level without modify backlight_config to keep ability to restore state
1507 backlight_set(bl_toggle_lvl);
1510 led_set_kb(usb_led);
1514 //------------------------------------------------------------------------------
1515 // Override these functions in your keymap file to play different tunes on
1516 // different events such as startup and bootloader jump
1518 __attribute__ ((weak))
1519 void startup_user() {}
1521 __attribute__ ((weak))
1522 void shutdown_user() {}
1524 //------------------------------------------------------------------------------