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
198 // Shift / Enter setup
200 #define SFTENT_KEY KC_ENT
203 static bool shift_interrupted[2] = {0, 0};
204 static uint16_t scs_timer[2] = {0, 0};
206 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
207 * Used to ensure that the correct keycode is released if the key is released.
209 static bool grave_esc_was_shifted = false;
211 bool process_record_quantum(keyrecord_t *record) {
213 /* This gets the keycode from the key pressed */
214 keypos_t key = record->event.key;
217 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
218 /* TODO: Use store_or_get_action() or a similar function. */
219 if (!disable_action_cache) {
222 if (record->event.pressed) {
223 layer = layer_switch_get_layer(key);
224 update_source_layers_cache(key, layer);
226 layer = read_source_layers_cache(key);
228 keycode = keymap_key_to_keycode(layer, key);
231 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
233 // This is how you use actions here
234 // if (keycode == KC_LEAD) {
236 // action.code = ACTION_DEFAULT_LAYER_SET(0);
237 // process_action(record, action);
241 #ifdef TAP_DANCE_ENABLE
242 preprocess_tap_dance(keycode, record);
246 #if defined(KEY_LOCK_ENABLE)
247 // Must run first to be able to mask key_up events.
248 process_key_lock(&keycode, record) &&
250 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
251 process_clicky(keycode, record) &&
252 #endif //AUDIO_CLICKY
253 process_record_kb(keycode, record) &&
254 #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
255 process_rgb_matrix(keycode, record) &&
257 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
258 process_midi(keycode, record) &&
261 process_audio(keycode, record) &&
264 process_steno(keycode, record) &&
266 #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
267 process_music(keycode, record) &&
269 #ifdef TAP_DANCE_ENABLE
270 process_tap_dance(keycode, record) &&
272 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
273 process_unicode_common(keycode, record) &&
276 process_leader(keycode, record) &&
279 process_combo(keycode, record) &&
281 #ifdef PRINTING_ENABLE
282 process_printer(keycode, record) &&
284 #ifdef AUTO_SHIFT_ENABLE
285 process_auto_shift(keycode, record) &&
287 #ifdef TERMINAL_ENABLE
288 process_terminal(keycode, record) &&
294 // Shift / paren setup
298 if (record->event.pressed) {
303 if (record->event.pressed) {
305 print("DEBUG: enabled.\n");
309 if (record->event.pressed) {
313 #ifdef FAUXCLICKY_ENABLE
315 if (record->event.pressed) {
320 if (record->event.pressed) {
325 if (record->event.pressed) {
330 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
332 // Split keyboards need to trigger on key-up for edge-case issue
333 #ifndef SPLIT_KEYBOARD
334 if (record->event.pressed) {
336 if (!record->event.pressed) {
339 #ifdef SPLIT_KEYBOARD
344 case RGB_MODE_FORWARD:
345 if (record->event.pressed) {
346 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
348 rgblight_step_reverse();
353 #ifdef SPLIT_KEYBOARD
358 case RGB_MODE_REVERSE:
359 if (record->event.pressed) {
360 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
365 rgblight_step_reverse();
367 #ifdef SPLIT_KEYBOARD
373 // Split keyboards need to trigger on key-up for edge-case issue
374 #ifndef SPLIT_KEYBOARD
375 if (record->event.pressed) {
377 if (!record->event.pressed) {
379 rgblight_increase_hue();
380 #ifdef SPLIT_KEYBOARD
386 // Split keyboards need to trigger on key-up for edge-case issue
387 #ifndef SPLIT_KEYBOARD
388 if (record->event.pressed) {
390 if (!record->event.pressed) {
392 rgblight_decrease_hue();
393 #ifdef SPLIT_KEYBOARD
399 // Split keyboards need to trigger on key-up for edge-case issue
400 #ifndef SPLIT_KEYBOARD
401 if (record->event.pressed) {
403 if (!record->event.pressed) {
405 rgblight_increase_sat();
406 #ifdef SPLIT_KEYBOARD
412 // Split keyboards need to trigger on key-up for edge-case issue
413 #ifndef SPLIT_KEYBOARD
414 if (record->event.pressed) {
416 if (!record->event.pressed) {
418 rgblight_decrease_sat();
419 #ifdef SPLIT_KEYBOARD
425 // Split keyboards need to trigger on key-up for edge-case issue
426 #ifndef SPLIT_KEYBOARD
427 if (record->event.pressed) {
429 if (!record->event.pressed) {
431 rgblight_increase_val();
432 #ifdef SPLIT_KEYBOARD
438 // Split keyboards need to trigger on key-up for edge-case issue
439 #ifndef SPLIT_KEYBOARD
440 if (record->event.pressed) {
442 if (!record->event.pressed) {
444 rgblight_decrease_val();
445 #ifdef SPLIT_KEYBOARD
451 if (record->event.pressed) {
452 rgblight_increase_speed();
456 if (record->event.pressed) {
457 rgblight_decrease_speed();
461 if (record->event.pressed) {
462 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
463 #ifdef SPLIT_KEYBOARD
468 case RGB_MODE_BREATHE:
469 #ifdef RGBLIGHT_EFFECT_BREATHING
470 if (record->event.pressed) {
471 if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
472 (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
475 rgblight_mode(RGBLIGHT_MODE_BREATHING);
480 case RGB_MODE_RAINBOW:
481 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
482 if (record->event.pressed) {
483 if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
484 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
487 rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
493 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
494 if (record->event.pressed) {
495 if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
496 (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
499 rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
505 #ifdef RGBLIGHT_EFFECT_SNAKE
506 if (record->event.pressed) {
507 if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
508 (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
511 rgblight_mode(RGBLIGHT_MODE_SNAKE);
516 case RGB_MODE_KNIGHT:
517 #ifdef RGBLIGHT_EFFECT_KNIGHT
518 if (record->event.pressed) {
519 if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
520 (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
523 rgblight_mode(RGBLIGHT_MODE_KNIGHT);
529 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
530 if (record->event.pressed) {
531 rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
535 case RGB_MODE_GRADIENT:
536 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
537 if (record->event.pressed) {
538 if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
539 (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
542 rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
547 case RGB_MODE_RGBTEST:
548 #ifdef RGBLIGHT_EFFECT_RGB_TEST
549 if (record->event.pressed) {
550 rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
554 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
557 if (record->event.pressed) {
558 set_output(OUTPUT_AUTO);
562 if (record->event.pressed) {
563 set_output(OUTPUT_USB);
566 #ifdef BLUETOOTH_ENABLE
568 if (record->event.pressed) {
569 set_output(OUTPUT_BLUETOOTH);
574 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
575 if (record->event.pressed) {
576 // MAGIC actions (BOOTMAGIC without the boot)
577 if (!eeconfig_is_enabled()) {
581 keymap_config.raw = eeconfig_read_keymap();
584 case MAGIC_SWAP_CONTROL_CAPSLOCK:
585 keymap_config.swap_control_capslock = true;
587 case MAGIC_CAPSLOCK_TO_CONTROL:
588 keymap_config.capslock_to_control = true;
590 case MAGIC_SWAP_LALT_LGUI:
591 keymap_config.swap_lalt_lgui = true;
593 case MAGIC_SWAP_RALT_RGUI:
594 keymap_config.swap_ralt_rgui = true;
597 keymap_config.no_gui = true;
599 case MAGIC_SWAP_GRAVE_ESC:
600 keymap_config.swap_grave_esc = true;
602 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
603 keymap_config.swap_backslash_backspace = true;
605 case MAGIC_HOST_NKRO:
606 keymap_config.nkro = true;
608 case MAGIC_SWAP_ALT_GUI:
609 keymap_config.swap_lalt_lgui = true;
610 keymap_config.swap_ralt_rgui = true;
612 PLAY_SONG(ag_swap_song);
615 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
616 keymap_config.swap_control_capslock = false;
618 case MAGIC_UNCAPSLOCK_TO_CONTROL:
619 keymap_config.capslock_to_control = false;
621 case MAGIC_UNSWAP_LALT_LGUI:
622 keymap_config.swap_lalt_lgui = false;
624 case MAGIC_UNSWAP_RALT_RGUI:
625 keymap_config.swap_ralt_rgui = false;
628 keymap_config.no_gui = false;
630 case MAGIC_UNSWAP_GRAVE_ESC:
631 keymap_config.swap_grave_esc = false;
633 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
634 keymap_config.swap_backslash_backspace = false;
636 case MAGIC_UNHOST_NKRO:
637 keymap_config.nkro = false;
639 case MAGIC_UNSWAP_ALT_GUI:
640 keymap_config.swap_lalt_lgui = false;
641 keymap_config.swap_ralt_rgui = false;
643 PLAY_SONG(ag_norm_song);
646 case MAGIC_TOGGLE_ALT_GUI:
647 keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
648 keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
650 if (keymap_config.swap_ralt_rgui) {
651 PLAY_SONG(ag_swap_song);
653 PLAY_SONG(ag_norm_song);
657 case MAGIC_TOGGLE_NKRO:
658 keymap_config.nkro = !keymap_config.nkro;
663 eeconfig_update_keymap(keymap_config.raw);
664 clear_keyboard(); // clear to prevent stuck keys
670 if (record->event.pressed) {
671 shift_interrupted[0] = false;
672 scs_timer[0] = timer_read ();
673 register_mods(MOD_BIT(KC_LSFT));
676 #ifdef DISABLE_SPACE_CADET_ROLLOVER
677 if (get_mods() & MOD_BIT(KC_RSFT)) {
678 shift_interrupted[0] = true;
679 shift_interrupted[1] = true;
682 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
683 register_code(LSPO_KEY);
684 unregister_code(LSPO_KEY);
686 unregister_mods(MOD_BIT(KC_LSFT));
692 if (record->event.pressed) {
693 shift_interrupted[1] = false;
694 scs_timer[1] = timer_read ();
695 register_mods(MOD_BIT(KC_RSFT));
698 #ifdef DISABLE_SPACE_CADET_ROLLOVER
699 if (get_mods() & MOD_BIT(KC_LSFT)) {
700 shift_interrupted[0] = true;
701 shift_interrupted[1] = true;
704 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
705 register_code(RSPC_KEY);
706 unregister_code(RSPC_KEY);
708 unregister_mods(MOD_BIT(KC_RSFT));
714 if (record->event.pressed) {
715 shift_interrupted[1] = false;
716 scs_timer[1] = timer_read ();
717 register_mods(MOD_BIT(KC_RSFT));
719 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
720 unregister_mods(MOD_BIT(KC_RSFT));
721 register_code(SFTENT_KEY);
722 unregister_code(SFTENT_KEY);
725 unregister_mods(MOD_BIT(KC_RSFT));
731 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
732 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
734 #ifdef GRAVE_ESC_ALT_OVERRIDE
735 // if ALT is pressed, ESC is always sent
736 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
737 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
742 #ifdef GRAVE_ESC_CTRL_OVERRIDE
743 // if CTRL is pressed, ESC is always sent
744 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
745 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
750 #ifdef GRAVE_ESC_GUI_OVERRIDE
751 // if GUI is pressed, ESC is always sent
752 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
757 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
758 // if SHIFT is pressed, ESC is always sent
759 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
764 if (record->event.pressed) {
765 grave_esc_was_shifted = shifted;
766 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
769 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
772 send_keyboard_report();
776 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
778 if (record->event.pressed)
785 shift_interrupted[0] = true;
786 shift_interrupted[1] = true;
791 return process_action_kb(record);
794 __attribute__ ((weak))
795 const bool ascii_to_shift_lut[0x80] PROGMEM = {
796 0, 0, 0, 0, 0, 0, 0, 0,
797 0, 0, 0, 0, 0, 0, 0, 0,
798 0, 0, 0, 0, 0, 0, 0, 0,
799 0, 0, 0, 0, 0, 0, 0, 0,
800 0, 1, 1, 1, 1, 1, 1, 0,
801 1, 1, 1, 1, 0, 0, 0, 0,
802 0, 0, 0, 0, 0, 0, 0, 0,
803 0, 0, 1, 0, 1, 0, 1, 1,
804 1, 1, 1, 1, 1, 1, 1, 1,
805 1, 1, 1, 1, 1, 1, 1, 1,
806 1, 1, 1, 1, 1, 1, 1, 1,
807 1, 1, 1, 0, 0, 0, 1, 1,
808 0, 0, 0, 0, 0, 0, 0, 0,
809 0, 0, 0, 0, 0, 0, 0, 0,
810 0, 0, 0, 0, 0, 0, 0, 0,
811 0, 0, 0, 1, 1, 1, 1, 0
814 __attribute__ ((weak))
815 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
816 0, 0, 0, 0, 0, 0, 0, 0,
817 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
818 0, 0, 0, 0, 0, 0, 0, 0,
819 0, 0, 0, KC_ESC, 0, 0, 0, 0,
820 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
821 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
822 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
823 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
824 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
825 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
826 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
827 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
828 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
829 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
830 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
831 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
834 void send_string(const char *str) {
835 send_string_with_delay(str, 0);
838 void send_string_P(const char *str) {
839 send_string_with_delay_P(str, 0);
842 void send_string_with_delay(const char *str, uint8_t interval) {
844 char ascii_code = *str;
845 if (!ascii_code) break;
846 if (ascii_code == 1) {
848 uint8_t keycode = *(++str);
849 register_code(keycode);
850 unregister_code(keycode);
851 } else if (ascii_code == 2) {
853 uint8_t keycode = *(++str);
854 register_code(keycode);
855 } else if (ascii_code == 3) {
857 uint8_t keycode = *(++str);
858 unregister_code(keycode);
860 send_char(ascii_code);
864 { uint8_t ms = interval; while (ms--) wait_ms(1); }
868 void send_string_with_delay_P(const char *str, uint8_t interval) {
870 char ascii_code = pgm_read_byte(str);
871 if (!ascii_code) break;
872 if (ascii_code == 1) {
874 uint8_t keycode = pgm_read_byte(++str);
875 register_code(keycode);
876 unregister_code(keycode);
877 } else if (ascii_code == 2) {
879 uint8_t keycode = pgm_read_byte(++str);
880 register_code(keycode);
881 } else if (ascii_code == 3) {
883 uint8_t keycode = pgm_read_byte(++str);
884 unregister_code(keycode);
886 send_char(ascii_code);
890 { uint8_t ms = interval; while (ms--) wait_ms(1); }
894 void send_char(char ascii_code) {
896 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
897 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
898 register_code(KC_LSFT);
899 register_code(keycode);
900 unregister_code(keycode);
901 unregister_code(KC_LSFT);
903 register_code(keycode);
904 unregister_code(keycode);
908 void set_single_persistent_default_layer(uint8_t default_layer) {
909 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
910 PLAY_SONG(default_layer_songs[default_layer]);
912 eeconfig_update_default_layer(1U<<default_layer);
913 default_layer_set(1U<<default_layer);
916 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
917 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
918 uint32_t mask3 = 1UL << layer3;
919 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
922 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
923 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
926 void tap_random_base64(void) {
927 #if defined(__AVR_ATmega32U4__)
928 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
930 uint8_t key = rand() % 64;
934 register_code(KC_LSFT);
935 register_code(key + KC_A);
936 unregister_code(key + KC_A);
937 unregister_code(KC_LSFT);
940 register_code(key - 26 + KC_A);
941 unregister_code(key - 26 + KC_A);
945 unregister_code(KC_0);
948 register_code(key - 53 + KC_1);
949 unregister_code(key - 53 + KC_1);
952 register_code(KC_LSFT);
953 register_code(KC_EQL);
954 unregister_code(KC_EQL);
955 unregister_code(KC_LSFT);
958 register_code(KC_SLSH);
959 unregister_code(KC_SLSH);
964 __attribute__((weak))
965 void bootmagic_lite(void) {
966 // The lite version of TMK's bootmagic based on Wilba.
967 // 100% less potential for accidentally making the
968 // keyboard do stupid things.
970 // We need multiple scans because debouncing can't be turned off.
972 #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
973 wait_ms(DEBOUNCING_DELAY * 2);
974 #elif defined(DEBOUNCE) && DEBOUNCE > 0
975 wait_ms(DEBOUNCE * 2);
981 // If the Esc and space bar are held down on power up,
982 // reset the EEPROM valid state and jump to bootloader.
983 // Assumes Esc is at [0,0].
984 // This isn't very generalized, but we need something that doesn't
985 // rely on user's keymaps in firmware or EEPROM.
986 if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
988 // Jump to bootloader.
993 void matrix_init_quantum() {
994 #ifdef BOOTMAGIC_LITE
997 if (!eeconfig_is_enabled()) {
1000 #ifdef BACKLIGHT_ENABLE
1001 backlight_init_ports();
1006 #ifdef RGB_MATRIX_ENABLE
1009 #ifdef ENCODER_ENABLE
1012 #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1013 unicode_input_mode_init();
1018 uint8_t rgb_matrix_task_counter = 0;
1020 #ifndef RGB_MATRIX_SKIP_FRAMES
1021 #define RGB_MATRIX_SKIP_FRAMES 1
1024 void matrix_scan_quantum() {
1025 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1026 matrix_scan_music();
1029 #ifdef TAP_DANCE_ENABLE
1030 matrix_scan_tap_dance();
1034 matrix_scan_combo();
1037 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1041 #ifdef RGB_MATRIX_ENABLE
1043 if (rgb_matrix_task_counter == 0) {
1044 rgb_matrix_update_pwm_buffers();
1046 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1049 #ifdef ENCODER_ENABLE
1055 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1057 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1059 // depending on the pin, we use a different output compare unit
1060 #if BACKLIGHT_PIN == B7
1061 # define TCCRxA TCCR1A
1062 # define TCCRxB TCCR1B
1063 # define COMxx1 COM1C1
1064 # define OCRxx OCR1C
1066 #elif BACKLIGHT_PIN == B6
1067 # define TCCRxA TCCR1A
1068 # define TCCRxB TCCR1B
1069 # define COMxx1 COM1B1
1070 # define OCRxx OCR1B
1072 #elif BACKLIGHT_PIN == B5
1073 # define TCCRxA TCCR1A
1074 # define TCCRxB TCCR1B
1075 # define COMxx1 COM1A1
1076 # define OCRxx OCR1A
1078 #elif BACKLIGHT_PIN == C6
1079 # define TCCRxA TCCR3A
1080 # define TCCRxB TCCR3B
1081 # define COMxx1 COM1A1
1082 # define OCRxx OCR3A
1085 # define NO_HARDWARE_PWM
1088 #ifndef BACKLIGHT_ON_STATE
1089 #define BACKLIGHT_ON_STATE 0
1092 #ifdef NO_HARDWARE_PWM // pwm through software
1094 __attribute__ ((weak))
1095 void backlight_init_ports(void)
1097 // Setup backlight pin as output and output to on state.
1099 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1100 #if BACKLIGHT_ON_STATE == 0
1102 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1105 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1109 __attribute__ ((weak))
1110 void backlight_set(uint8_t level) {}
1112 uint8_t backlight_tick = 0;
1114 #ifndef BACKLIGHT_CUSTOM_DRIVER
1115 void backlight_task(void) {
1116 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1117 #if BACKLIGHT_ON_STATE == 0
1119 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1122 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1125 #if BACKLIGHT_ON_STATE == 0
1127 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1130 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1133 backlight_tick = (backlight_tick + 1) % 16;
1137 #ifdef BACKLIGHT_BREATHING
1138 #ifndef BACKLIGHT_CUSTOM_DRIVER
1139 #error "Backlight breathing only available with hardware PWM. Please disable."
1143 #else // pwm through timer
1145 #define TIMER_TOP 0xFFFFU
1147 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1148 static uint16_t cie_lightness(uint16_t v) {
1149 if (v <= 5243) // if below 8% of max
1150 return v / 9; // same as dividing by 900%
1152 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1153 // to get a useful result with integer division, we shift left in the expression above
1154 // and revert what we've done again after squaring.
1156 if (y > 0xFFFFUL) // prevent overflow
1159 return (uint16_t) y;
1163 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1164 static inline void set_pwm(uint16_t val) {
1168 #ifndef BACKLIGHT_CUSTOM_DRIVER
1169 __attribute__ ((weak))
1170 void backlight_set(uint8_t level) {
1171 if (level > BACKLIGHT_LEVELS)
1172 level = BACKLIGHT_LEVELS;
1175 // Turn off PWM control on backlight pin
1176 TCCRxA &= ~(_BV(COMxx1));
1178 // Turn on PWM control of backlight pin
1179 TCCRxA |= _BV(COMxx1);
1181 // Set the brightness
1182 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1185 void backlight_task(void) {}
1186 #endif // BACKLIGHT_CUSTOM_DRIVER
1188 #ifdef BACKLIGHT_BREATHING
1190 #define BREATHING_NO_HALT 0
1191 #define BREATHING_HALT_OFF 1
1192 #define BREATHING_HALT_ON 2
1193 #define BREATHING_STEPS 128
1195 static uint8_t breathing_period = BREATHING_PERIOD;
1196 static uint8_t breathing_halt = BREATHING_NO_HALT;
1197 static uint16_t breathing_counter = 0;
1199 bool is_breathing(void) {
1200 return !!(TIMSK1 & _BV(TOIE1));
1203 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1204 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1205 #define breathing_min() do {breathing_counter = 0;} while (0)
1206 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1208 void breathing_enable(void)
1210 breathing_counter = 0;
1211 breathing_halt = BREATHING_NO_HALT;
1212 breathing_interrupt_enable();
1215 void breathing_pulse(void)
1217 if (get_backlight_level() == 0)
1221 breathing_halt = BREATHING_HALT_ON;
1222 breathing_interrupt_enable();
1225 void breathing_disable(void)
1227 breathing_interrupt_disable();
1228 // Restore backlight level
1229 backlight_set(get_backlight_level());
1232 void breathing_self_disable(void)
1234 if (get_backlight_level() == 0)
1235 breathing_halt = BREATHING_HALT_OFF;
1237 breathing_halt = BREATHING_HALT_ON;
1240 void breathing_toggle(void) {
1242 breathing_disable();
1247 void breathing_period_set(uint8_t value)
1251 breathing_period = value;
1254 void breathing_period_default(void) {
1255 breathing_period_set(BREATHING_PERIOD);
1258 void breathing_period_inc(void)
1260 breathing_period_set(breathing_period+1);
1263 void breathing_period_dec(void)
1265 breathing_period_set(breathing_period-1);
1268 /* To generate breathing curve in python:
1269 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1271 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};
1273 // Use this before the cie_lightness function.
1274 static inline uint16_t scale_backlight(uint16_t v) {
1275 return v / BACKLIGHT_LEVELS * get_backlight_level();
1278 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1279 * about 244 times per second.
1281 ISR(TIMER1_OVF_vect)
1283 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1284 // resetting after one period to prevent ugly reset at overflow.
1285 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1286 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1288 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1289 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1291 breathing_interrupt_disable();
1294 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1297 #endif // BACKLIGHT_BREATHING
1299 __attribute__ ((weak))
1300 void backlight_init_ports(void)
1302 // Setup backlight pin as output and output to on state.
1304 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1305 #if BACKLIGHT_ON_STATE == 0
1307 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1310 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1312 // I could write a wall of text here to explain... but TL;DW
1313 // Go read the ATmega32u4 datasheet.
1314 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1316 // Pin PB7 = OCR1C (Timer 1, Channel C)
1317 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1318 // (i.e. start high, go low when counter matches.)
1319 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1320 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1324 "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 [..]."
1325 "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)."
1327 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1328 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1329 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1333 #ifdef BACKLIGHT_BREATHING
1338 #endif // NO_HARDWARE_PWM
1342 __attribute__ ((weak))
1343 void backlight_init_ports(void) {}
1345 __attribute__ ((weak))
1346 void backlight_set(uint8_t level) {}
1350 #ifdef HD44780_ENABLED
1351 #include "hd44780.h"
1355 // Functions for spitting out values
1358 void send_dword(uint32_t number) { // this might not actually work
1359 uint16_t word = (number >> 16);
1361 send_word(number & 0xFFFFUL);
1364 void send_word(uint16_t number) {
1365 uint8_t byte = number >> 8;
1367 send_byte(number & 0xFF);
1370 void send_byte(uint8_t number) {
1371 uint8_t nibble = number >> 4;
1372 send_nibble(nibble);
1373 send_nibble(number & 0xF);
1376 void send_nibble(uint8_t number) {
1379 register_code(KC_0);
1380 unregister_code(KC_0);
1383 register_code(KC_1 + (number - 1));
1384 unregister_code(KC_1 + (number - 1));
1387 register_code(KC_A + (number - 0xA));
1388 unregister_code(KC_A + (number - 0xA));
1394 __attribute__((weak))
1395 uint16_t hex_to_keycode(uint8_t hex)
1400 } else if (hex < 0xA) {
1401 return KC_1 + (hex - 0x1);
1403 return KC_A + (hex - 0xA);
1407 void api_send_unicode(uint32_t unicode) {
1410 dword_to_bytes(unicode, chunk);
1411 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1415 __attribute__ ((weak))
1416 void led_set_user(uint8_t usb_led) {
1420 __attribute__ ((weak))
1421 void led_set_kb(uint8_t usb_led) {
1422 led_set_user(usb_led);
1425 __attribute__ ((weak))
1426 void led_init_ports(void)
1431 __attribute__ ((weak))
1432 void led_set(uint8_t usb_led)
1437 // // Using PE6 Caps Lock LED
1438 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1448 // PORTE &= ~(1<<6);
1451 led_set_kb(usb_led);
1455 //------------------------------------------------------------------------------
1456 // Override these functions in your keymap file to play different tunes on
1457 // different events such as startup and bootloader jump
1459 __attribute__ ((weak))
1460 void startup_user() {}
1462 __attribute__ ((weak))
1463 void shutdown_user() {}
1465 //------------------------------------------------------------------------------