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 #include "outputselect.h"
23 #define TAPPING_TERM 200
26 #ifndef BREATHING_PERIOD
27 #define BREATHING_PERIOD 6
30 #include "backlight.h"
31 extern backlight_config_t backlight_config;
33 #ifdef FAUXCLICKY_ENABLE
34 #include "fauxclicky.h"
42 #include "process_midi.h"
47 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
50 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
53 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
55 float goodbye_song[][2] = GOODBYE_SONG;
56 float ag_norm_song[][2] = AG_NORM_SONG;
57 float ag_swap_song[][2] = AG_SWAP_SONG;
58 #ifdef DEFAULT_LAYER_SONGS
59 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
63 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
65 case QK_MODS ... QK_MODS_MAX:
80 if (code < QK_RMODS_MIN) return;
92 static inline void qk_register_weak_mods(uint8_t kc) {
93 add_weak_mods(MOD_BIT(kc));
94 send_keyboard_report();
97 static inline void qk_unregister_weak_mods(uint8_t kc) {
98 del_weak_mods(MOD_BIT(kc));
99 send_keyboard_report();
102 static inline void qk_register_mods(uint8_t kc) {
103 add_weak_mods(MOD_BIT(kc));
104 send_keyboard_report();
107 static inline void qk_unregister_mods(uint8_t kc) {
108 del_weak_mods(MOD_BIT(kc));
109 send_keyboard_report();
112 void register_code16 (uint16_t code) {
113 if (IS_MOD(code) || code == KC_NO) {
114 do_code16 (code, qk_register_mods);
116 do_code16 (code, qk_register_weak_mods);
118 register_code (code);
121 void unregister_code16 (uint16_t code) {
122 unregister_code (code);
123 if (IS_MOD(code) || code == KC_NO) {
124 do_code16 (code, qk_unregister_mods);
126 do_code16 (code, qk_unregister_weak_mods);
130 __attribute__ ((weak))
131 bool process_action_kb(keyrecord_t *record) {
135 __attribute__ ((weak))
136 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
137 return process_record_user(keycode, record);
140 __attribute__ ((weak))
141 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
145 void reset_keyboard(void) {
147 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
148 process_midi_all_notes_off();
151 #ifndef NO_MUSIC_MODE
152 music_all_notes_off();
154 uint16_t timer_start = timer_read();
155 PLAY_SONG(goodbye_song);
157 while(timer_elapsed(timer_start) < 250)
164 // this is also done later in bootloader.c - not sure if it's neccesary here
165 #ifdef BOOTLOADER_CATERINA
166 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
171 // Shift / paren setup
174 #define LSPO_KEY KC_9
177 #define RSPC_KEY KC_0
180 // Shift / Enter setup
182 #define SFTENT_KEY KC_ENT
185 static bool shift_interrupted[2] = {0, 0};
186 static uint16_t scs_timer[2] = {0, 0};
188 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
189 * Used to ensure that the correct keycode is released if the key is released.
191 static bool grave_esc_was_shifted = false;
193 bool process_record_quantum(keyrecord_t *record) {
195 /* This gets the keycode from the key pressed */
196 keypos_t key = record->event.key;
199 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
200 /* TODO: Use store_or_get_action() or a similar function. */
201 if (!disable_action_cache) {
204 if (record->event.pressed) {
205 layer = layer_switch_get_layer(key);
206 update_source_layers_cache(key, layer);
208 layer = read_source_layers_cache(key);
210 keycode = keymap_key_to_keycode(layer, key);
213 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
215 // This is how you use actions here
216 // if (keycode == KC_LEAD) {
218 // action.code = ACTION_DEFAULT_LAYER_SET(0);
219 // process_action(record, action);
223 #ifdef TAP_DANCE_ENABLE
224 preprocess_tap_dance(keycode, record);
228 #if defined(KEY_LOCK_ENABLE)
229 // Must run first to be able to mask key_up events.
230 process_key_lock(&keycode, record) &&
232 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
233 process_clicky(keycode, record) &&
234 #endif //AUDIO_CLICKY
235 process_record_kb(keycode, record) &&
236 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
237 process_rgb_matrix(keycode, record) &&
239 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
240 process_midi(keycode, record) &&
243 process_audio(keycode, record) &&
246 process_steno(keycode, record) &&
248 #if ( defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
249 process_music(keycode, record) &&
251 #ifdef TAP_DANCE_ENABLE
252 process_tap_dance(keycode, record) &&
255 process_leader(keycode, record) &&
258 process_combo(keycode, record) &&
260 #ifdef UNICODE_ENABLE
261 process_unicode(keycode, record) &&
264 process_ucis(keycode, record) &&
266 #ifdef PRINTING_ENABLE
267 process_printer(keycode, record) &&
269 #ifdef AUTO_SHIFT_ENABLE
270 process_auto_shift(keycode, record) &&
272 #ifdef UNICODEMAP_ENABLE
273 process_unicode_map(keycode, record) &&
275 #ifdef TERMINAL_ENABLE
276 process_terminal(keycode, record) &&
282 // Shift / paren setup
286 if (record->event.pressed) {
291 if (record->event.pressed) {
293 print("DEBUG: enabled.\n");
296 #ifdef FAUXCLICKY_ENABLE
298 if (record->event.pressed) {
303 if (record->event.pressed) {
308 if (record->event.pressed) {
313 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
315 // Split keyboards need to trigger on key-up for edge-case issue
316 #ifndef SPLIT_KEYBOARD
317 if (record->event.pressed) {
319 if (!record->event.pressed) {
322 #ifdef SPLIT_KEYBOARD
327 case RGB_MODE_FORWARD:
328 if (record->event.pressed) {
329 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
331 rgblight_step_reverse();
336 #ifdef SPLIT_KEYBOARD
341 case RGB_MODE_REVERSE:
342 if (record->event.pressed) {
343 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
348 rgblight_step_reverse();
350 #ifdef SPLIT_KEYBOARD
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) {
362 rgblight_increase_hue();
363 #ifdef SPLIT_KEYBOARD
369 // Split keyboards need to trigger on key-up for edge-case issue
370 #ifndef SPLIT_KEYBOARD
371 if (record->event.pressed) {
373 if (!record->event.pressed) {
375 rgblight_decrease_hue();
376 #ifdef SPLIT_KEYBOARD
382 // Split keyboards need to trigger on key-up for edge-case issue
383 #ifndef SPLIT_KEYBOARD
384 if (record->event.pressed) {
386 if (!record->event.pressed) {
388 rgblight_increase_sat();
389 #ifdef SPLIT_KEYBOARD
395 // Split keyboards need to trigger on key-up for edge-case issue
396 #ifndef SPLIT_KEYBOARD
397 if (record->event.pressed) {
399 if (!record->event.pressed) {
401 rgblight_decrease_sat();
402 #ifdef SPLIT_KEYBOARD
408 // Split keyboards need to trigger on key-up for edge-case issue
409 #ifndef SPLIT_KEYBOARD
410 if (record->event.pressed) {
412 if (!record->event.pressed) {
414 rgblight_increase_val();
415 #ifdef SPLIT_KEYBOARD
421 // Split keyboards need to trigger on key-up for edge-case issue
422 #ifndef SPLIT_KEYBOARD
423 if (record->event.pressed) {
425 if (!record->event.pressed) {
427 rgblight_decrease_val();
428 #ifdef SPLIT_KEYBOARD
434 if (record->event.pressed) {
435 rgblight_increase_speed();
439 if (record->event.pressed) {
440 rgblight_decrease_speed();
444 if (record->event.pressed) {
445 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
446 #ifdef SPLIT_KEYBOARD
451 case RGB_MODE_BREATHE:
452 #ifdef RGBLIGHT_EFFECT_BREATHING
453 if (record->event.pressed) {
454 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
455 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
458 rgblight_mode(RGBLIGHT_MODE_BREATHING);
463 case RGB_MODE_RAINBOW:
464 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
465 if (record->event.pressed) {
466 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
467 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
470 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
476 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
477 if (record->event.pressed) {
478 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
479 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
482 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
488 #ifdef RGBLIGHT_EFFECT_SNAKE
489 if (record->event.pressed) {
490 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
491 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
494 rgblight_mode(RGBLIGHT_MODE_SNAKE);
499 case RGB_MODE_KNIGHT:
500 #ifdef RGBLIGHT_EFFECT_KNIGHT
501 if (record->event.pressed) {
502 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
503 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
506 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
512 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
513 if (record->event.pressed) {
514 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
518 case RGB_MODE_GRADIENT:
519 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
520 if (record->event.pressed) {
521 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
522 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
525 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
530 case RGB_MODE_RGBTEST:
531 #ifdef RGBLIGHT_EFFECT_RGB_TEST
532 if (record->event.pressed) {
533 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
537 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
540 if (record->event.pressed) {
541 set_output(OUTPUT_AUTO);
545 if (record->event.pressed) {
546 set_output(OUTPUT_USB);
549 #ifdef BLUETOOTH_ENABLE
551 if (record->event.pressed) {
552 set_output(OUTPUT_BLUETOOTH);
557 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
558 if (record->event.pressed) {
559 // MAGIC actions (BOOTMAGIC without the boot)
560 if (!eeconfig_is_enabled()) {
564 keymap_config.raw = eeconfig_read_keymap();
567 case MAGIC_SWAP_CONTROL_CAPSLOCK:
568 keymap_config.swap_control_capslock = true;
570 case MAGIC_CAPSLOCK_TO_CONTROL:
571 keymap_config.capslock_to_control = true;
573 case MAGIC_SWAP_LALT_LGUI:
574 keymap_config.swap_lalt_lgui = true;
576 case MAGIC_SWAP_RALT_RGUI:
577 keymap_config.swap_ralt_rgui = true;
580 keymap_config.no_gui = true;
582 case MAGIC_SWAP_GRAVE_ESC:
583 keymap_config.swap_grave_esc = true;
585 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
586 keymap_config.swap_backslash_backspace = true;
588 case MAGIC_HOST_NKRO:
589 keymap_config.nkro = true;
591 case MAGIC_SWAP_ALT_GUI:
592 keymap_config.swap_lalt_lgui = true;
593 keymap_config.swap_ralt_rgui = true;
595 PLAY_SONG(ag_swap_song);
598 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
599 keymap_config.swap_control_capslock = false;
601 case MAGIC_UNCAPSLOCK_TO_CONTROL:
602 keymap_config.capslock_to_control = false;
604 case MAGIC_UNSWAP_LALT_LGUI:
605 keymap_config.swap_lalt_lgui = false;
607 case MAGIC_UNSWAP_RALT_RGUI:
608 keymap_config.swap_ralt_rgui = false;
611 keymap_config.no_gui = false;
613 case MAGIC_UNSWAP_GRAVE_ESC:
614 keymap_config.swap_grave_esc = false;
616 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
617 keymap_config.swap_backslash_backspace = false;
619 case MAGIC_UNHOST_NKRO:
620 keymap_config.nkro = false;
622 case MAGIC_UNSWAP_ALT_GUI:
623 keymap_config.swap_lalt_lgui = false;
624 keymap_config.swap_ralt_rgui = false;
626 PLAY_SONG(ag_norm_song);
629 case MAGIC_TOGGLE_ALT_GUI:
630 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
631 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
633 if (keymap_config.swap_ralt_rgui) {
634 PLAY_SONG(ag_swap_song);
636 PLAY_SONG(ag_norm_song);
640 case MAGIC_TOGGLE_NKRO:
641 keymap_config.nkro = !keymap_config.nkro;
646 eeconfig_update_keymap(keymap_config.raw);
647 clear_keyboard(); // clear to prevent stuck keys
653 if (record->event.pressed) {
654 shift_interrupted[0] = false;
655 scs_timer[0] = timer_read ();
656 register_mods(MOD_BIT(KC_LSFT));
659 #ifdef DISABLE_SPACE_CADET_ROLLOVER
660 if (get_mods() & MOD_BIT(KC_RSFT)) {
661 shift_interrupted[0] = true;
662 shift_interrupted[1] = true;
665 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
666 register_code(LSPO_KEY);
667 unregister_code(LSPO_KEY);
669 unregister_mods(MOD_BIT(KC_LSFT));
675 if (record->event.pressed) {
676 shift_interrupted[1] = false;
677 scs_timer[1] = timer_read ();
678 register_mods(MOD_BIT(KC_RSFT));
681 #ifdef DISABLE_SPACE_CADET_ROLLOVER
682 if (get_mods() & MOD_BIT(KC_LSFT)) {
683 shift_interrupted[0] = true;
684 shift_interrupted[1] = true;
687 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
688 register_code(RSPC_KEY);
689 unregister_code(RSPC_KEY);
691 unregister_mods(MOD_BIT(KC_RSFT));
697 if (record->event.pressed) {
698 shift_interrupted[1] = false;
699 scs_timer[1] = timer_read ();
700 register_mods(MOD_BIT(KC_RSFT));
702 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
703 unregister_mods(MOD_BIT(KC_RSFT));
704 register_code(SFTENT_KEY);
705 unregister_code(SFTENT_KEY);
708 unregister_mods(MOD_BIT(KC_RSFT));
714 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
715 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
717 #ifdef GRAVE_ESC_ALT_OVERRIDE
718 // if ALT is pressed, ESC is always sent
719 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
720 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
725 #ifdef GRAVE_ESC_CTRL_OVERRIDE
726 // if CTRL is pressed, ESC is always sent
727 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
728 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
733 #ifdef GRAVE_ESC_GUI_OVERRIDE
734 // if GUI is pressed, ESC is always sent
735 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
740 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
741 // if SHIFT is pressed, ESC is always sent
742 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
747 if (record->event.pressed) {
748 grave_esc_was_shifted = shifted;
749 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
752 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
755 send_keyboard_report();
759 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
761 if (record->event.pressed)
768 shift_interrupted[0] = true;
769 shift_interrupted[1] = true;
774 return process_action_kb(record);
777 __attribute__ ((weak))
778 const bool ascii_to_shift_lut[0x80] PROGMEM = {
779 0, 0, 0, 0, 0, 0, 0, 0,
780 0, 0, 0, 0, 0, 0, 0, 0,
781 0, 0, 0, 0, 0, 0, 0, 0,
782 0, 0, 0, 0, 0, 0, 0, 0,
783 0, 1, 1, 1, 1, 1, 1, 0,
784 1, 1, 1, 1, 0, 0, 0, 0,
785 0, 0, 0, 0, 0, 0, 0, 0,
786 0, 0, 1, 0, 1, 0, 1, 1,
787 1, 1, 1, 1, 1, 1, 1, 1,
788 1, 1, 1, 1, 1, 1, 1, 1,
789 1, 1, 1, 1, 1, 1, 1, 1,
790 1, 1, 1, 0, 0, 0, 1, 1,
791 0, 0, 0, 0, 0, 0, 0, 0,
792 0, 0, 0, 0, 0, 0, 0, 0,
793 0, 0, 0, 0, 0, 0, 0, 0,
794 0, 0, 0, 1, 1, 1, 1, 0
797 __attribute__ ((weak))
798 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
799 0, 0, 0, 0, 0, 0, 0, 0,
800 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
801 0, 0, 0, 0, 0, 0, 0, 0,
802 0, 0, 0, KC_ESC, 0, 0, 0, 0,
803 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
804 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
805 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
806 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
807 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
808 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
809 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
810 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
811 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
812 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
813 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
814 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
817 void send_string(const char *str) {
818 send_string_with_delay(str, 0);
821 void send_string_P(const char *str) {
822 send_string_with_delay_P(str, 0);
825 void send_string_with_delay(const char *str, uint8_t interval) {
827 char ascii_code = *str;
828 if (!ascii_code) break;
829 if (ascii_code == 1) {
831 uint8_t keycode = *(++str);
832 register_code(keycode);
833 unregister_code(keycode);
834 } else if (ascii_code == 2) {
836 uint8_t keycode = *(++str);
837 register_code(keycode);
838 } else if (ascii_code == 3) {
840 uint8_t keycode = *(++str);
841 unregister_code(keycode);
843 send_char(ascii_code);
847 { uint8_t ms = interval; while (ms--) wait_ms(1); }
851 void send_string_with_delay_P(const char *str, uint8_t interval) {
853 char ascii_code = pgm_read_byte(str);
854 if (!ascii_code) break;
855 if (ascii_code == 1) {
857 uint8_t keycode = pgm_read_byte(++str);
858 register_code(keycode);
859 unregister_code(keycode);
860 } else if (ascii_code == 2) {
862 uint8_t keycode = pgm_read_byte(++str);
863 register_code(keycode);
864 } else if (ascii_code == 3) {
866 uint8_t keycode = pgm_read_byte(++str);
867 unregister_code(keycode);
869 send_char(ascii_code);
873 { uint8_t ms = interval; while (ms--) wait_ms(1); }
877 void send_char(char ascii_code) {
879 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
880 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
881 register_code(KC_LSFT);
882 register_code(keycode);
883 unregister_code(keycode);
884 unregister_code(KC_LSFT);
886 register_code(keycode);
887 unregister_code(keycode);
891 void set_single_persistent_default_layer(uint8_t default_layer) {
892 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
893 PLAY_SONG(default_layer_songs[default_layer]);
895 eeconfig_update_default_layer(1U<<default_layer);
896 default_layer_set(1U<<default_layer);
899 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
900 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
901 uint32_t mask3 = 1UL << layer3;
902 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
905 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
906 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
909 void tap_random_base64(void) {
910 #if defined(__AVR_ATmega32U4__)
911 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
913 uint8_t key = rand() % 64;
917 register_code(KC_LSFT);
918 register_code(key + KC_A);
919 unregister_code(key + KC_A);
920 unregister_code(KC_LSFT);
923 register_code(key - 26 + KC_A);
924 unregister_code(key - 26 + KC_A);
928 unregister_code(KC_0);
931 register_code(key - 53 + KC_1);
932 unregister_code(key - 53 + KC_1);
935 register_code(KC_LSFT);
936 register_code(KC_EQL);
937 unregister_code(KC_EQL);
938 unregister_code(KC_LSFT);
941 register_code(KC_SLSH);
942 unregister_code(KC_SLSH);
947 void matrix_init_quantum() {
948 if (!eeconfig_is_enabled() && !eeconfig_is_disabled()) {
951 #ifdef BACKLIGHT_ENABLE
952 backlight_init_ports();
957 #ifdef RGB_MATRIX_ENABLE
963 uint8_t rgb_matrix_task_counter = 0;
965 #ifndef RGB_MATRIX_SKIP_FRAMES
966 #define RGB_MATRIX_SKIP_FRAMES 1
969 void matrix_scan_quantum() {
970 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
974 #ifdef TAP_DANCE_ENABLE
975 matrix_scan_tap_dance();
982 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
986 #ifdef RGB_MATRIX_ENABLE
988 if (rgb_matrix_task_counter == 0) {
989 rgb_matrix_update_pwm_buffers();
991 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
996 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
998 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1000 // depending on the pin, we use a different output compare unit
1001 #if BACKLIGHT_PIN == B7
1002 # define TCCRxA TCCR1A
1003 # define TCCRxB TCCR1B
1004 # define COMxx1 COM1C1
1005 # define OCRxx OCR1C
1007 #elif BACKLIGHT_PIN == B6
1008 # define TCCRxA TCCR1A
1009 # define TCCRxB TCCR1B
1010 # define COMxx1 COM1B1
1011 # define OCRxx OCR1B
1013 #elif BACKLIGHT_PIN == B5
1014 # define TCCRxA TCCR1A
1015 # define TCCRxB TCCR1B
1016 # define COMxx1 COM1A1
1017 # define OCRxx OCR1A
1019 #elif BACKLIGHT_PIN == C6
1020 # define TCCRxA TCCR3A
1021 # define TCCRxB TCCR3B
1022 # define COMxx1 COM1A1
1023 # define OCRxx OCR3A
1026 # define NO_HARDWARE_PWM
1029 #ifndef BACKLIGHT_ON_STATE
1030 #define BACKLIGHT_ON_STATE 0
1033 #ifdef NO_HARDWARE_PWM // pwm through software
1035 __attribute__ ((weak))
1036 void backlight_init_ports(void)
1038 // Setup backlight pin as output and output to on state.
1040 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1041 #if BACKLIGHT_ON_STATE == 0
1043 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1046 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1050 __attribute__ ((weak))
1051 void backlight_set(uint8_t level) {}
1053 uint8_t backlight_tick = 0;
1055 #ifndef BACKLIGHT_CUSTOM_DRIVER
1056 void backlight_task(void) {
1057 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1058 #if BACKLIGHT_ON_STATE == 0
1060 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1063 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1066 #if BACKLIGHT_ON_STATE == 0
1068 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1071 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1074 backlight_tick = (backlight_tick + 1) % 16;
1078 #ifdef BACKLIGHT_BREATHING
1079 #ifndef BACKLIGHT_CUSTOM_DRIVER
1080 #error "Backlight breathing only available with hardware PWM. Please disable."
1084 #else // pwm through timer
1086 #define TIMER_TOP 0xFFFFU
1088 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1089 static uint16_t cie_lightness(uint16_t v) {
1090 if (v <= 5243) // if below 8% of max
1091 return v / 9; // same as dividing by 900%
1093 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1094 // to get a useful result with integer division, we shift left in the expression above
1095 // and revert what we've done again after squaring.
1097 if (y > 0xFFFFUL) // prevent overflow
1100 return (uint16_t) y;
1104 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1105 static inline void set_pwm(uint16_t val) {
1109 #ifndef BACKLIGHT_CUSTOM_DRIVER
1110 __attribute__ ((weak))
1111 void backlight_set(uint8_t level) {
1112 if (level > BACKLIGHT_LEVELS)
1113 level = BACKLIGHT_LEVELS;
1116 // Turn off PWM control on backlight pin
1117 TCCRxA &= ~(_BV(COMxx1));
1119 // Turn on PWM control of backlight pin
1120 TCCRxA |= _BV(COMxx1);
1122 // Set the brightness
1123 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1126 void backlight_task(void) {}
1127 #endif // BACKLIGHT_CUSTOM_DRIVER
1129 #ifdef BACKLIGHT_BREATHING
1131 #define BREATHING_NO_HALT 0
1132 #define BREATHING_HALT_OFF 1
1133 #define BREATHING_HALT_ON 2
1134 #define BREATHING_STEPS 128
1136 static uint8_t breathing_period = BREATHING_PERIOD;
1137 static uint8_t breathing_halt = BREATHING_NO_HALT;
1138 static uint16_t breathing_counter = 0;
1140 bool is_breathing(void) {
1141 return !!(TIMSK1 & _BV(TOIE1));
1144 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1145 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1146 #define breathing_min() do {breathing_counter = 0;} while (0)
1147 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1149 void breathing_enable(void)
1151 breathing_counter = 0;
1152 breathing_halt = BREATHING_NO_HALT;
1153 breathing_interrupt_enable();
1156 void breathing_pulse(void)
1158 if (get_backlight_level() == 0)
1162 breathing_halt = BREATHING_HALT_ON;
1163 breathing_interrupt_enable();
1166 void breathing_disable(void)
1168 breathing_interrupt_disable();
1169 // Restore backlight level
1170 backlight_set(get_backlight_level());
1173 void breathing_self_disable(void)
1175 if (get_backlight_level() == 0)
1176 breathing_halt = BREATHING_HALT_OFF;
1178 breathing_halt = BREATHING_HALT_ON;
1181 void breathing_toggle(void) {
1183 breathing_disable();
1188 void breathing_period_set(uint8_t value)
1192 breathing_period = value;
1195 void breathing_period_default(void) {
1196 breathing_period_set(BREATHING_PERIOD);
1199 void breathing_period_inc(void)
1201 breathing_period_set(breathing_period+1);
1204 void breathing_period_dec(void)
1206 breathing_period_set(breathing_period-1);
1209 /* To generate breathing curve in python:
1210 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1212 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};
1214 // Use this before the cie_lightness function.
1215 static inline uint16_t scale_backlight(uint16_t v) {
1216 return v / BACKLIGHT_LEVELS * get_backlight_level();
1219 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1220 * about 244 times per second.
1222 ISR(TIMER1_OVF_vect)
1224 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1225 // resetting after one period to prevent ugly reset at overflow.
1226 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1227 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1229 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1230 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1232 breathing_interrupt_disable();
1235 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1238 #endif // BACKLIGHT_BREATHING
1240 __attribute__ ((weak))
1241 void backlight_init_ports(void)
1243 // Setup backlight pin as output and output to on state.
1245 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1246 #if BACKLIGHT_ON_STATE == 0
1248 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1251 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1253 // I could write a wall of text here to explain... but TL;DW
1254 // Go read the ATmega32u4 datasheet.
1255 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1257 // Pin PB7 = OCR1C (Timer 1, Channel C)
1258 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1259 // (i.e. start high, go low when counter matches.)
1260 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1261 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1265 "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 [..]."
1266 "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)."
1268 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1269 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1270 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1274 #ifdef BACKLIGHT_BREATHING
1279 #endif // NO_HARDWARE_PWM
1283 __attribute__ ((weak))
1284 void backlight_init_ports(void) {}
1286 __attribute__ ((weak))
1287 void backlight_set(uint8_t level) {}
1291 #ifdef HD44780_ENABLED
1292 #include "hd44780.h"
1296 // Functions for spitting out values
1299 void send_dword(uint32_t number) { // this might not actually work
1300 uint16_t word = (number >> 16);
1302 send_word(number & 0xFFFFUL);
1305 void send_word(uint16_t number) {
1306 uint8_t byte = number >> 8;
1308 send_byte(number & 0xFF);
1311 void send_byte(uint8_t number) {
1312 uint8_t nibble = number >> 4;
1313 send_nibble(nibble);
1314 send_nibble(number & 0xF);
1317 void send_nibble(uint8_t number) {
1320 register_code(KC_0);
1321 unregister_code(KC_0);
1324 register_code(KC_1 + (number - 1));
1325 unregister_code(KC_1 + (number - 1));
1328 register_code(KC_A + (number - 0xA));
1329 unregister_code(KC_A + (number - 0xA));
1335 __attribute__((weak))
1336 uint16_t hex_to_keycode(uint8_t hex)
1341 } else if (hex < 0xA) {
1342 return KC_1 + (hex - 0x1);
1344 return KC_A + (hex - 0xA);
1348 void api_send_unicode(uint32_t unicode) {
1351 dword_to_bytes(unicode, chunk);
1352 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1356 __attribute__ ((weak))
1357 void led_set_user(uint8_t usb_led) {
1361 __attribute__ ((weak))
1362 void led_set_kb(uint8_t usb_led) {
1363 led_set_user(usb_led);
1366 __attribute__ ((weak))
1367 void led_init_ports(void)
1372 __attribute__ ((weak))
1373 void led_set(uint8_t usb_led)
1378 // // Using PE6 Caps Lock LED
1379 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1389 // PORTE &= ~(1<<6);
1392 led_set_kb(usb_led);
1396 //------------------------------------------------------------------------------
1397 // Override these functions in your keymap file to play different tunes on
1398 // different events such as startup and bootloader jump
1400 __attribute__ ((weak))
1401 void startup_user() {}
1403 __attribute__ ((weak))
1404 void shutdown_user() {}
1406 //------------------------------------------------------------------------------