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(PREVENT_STUCK_MODIFIERS)
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) &&
254 #ifndef DISABLE_LEADER
255 process_leader(keycode, record) &&
257 #ifndef DISABLE_CHORDING
258 process_chording(keycode, record) &&
261 process_combo(keycode, record) &&
263 #ifdef UNICODE_ENABLE
264 process_unicode(keycode, record) &&
267 process_ucis(keycode, record) &&
269 #ifdef PRINTING_ENABLE
270 process_printer(keycode, record) &&
272 #ifdef AUTO_SHIFT_ENABLE
273 process_auto_shift(keycode, record) &&
275 #ifdef UNICODEMAP_ENABLE
276 process_unicode_map(keycode, record) &&
278 #ifdef TERMINAL_ENABLE
279 process_terminal(keycode, record) &&
285 // Shift / paren setup
289 if (record->event.pressed) {
294 if (record->event.pressed) {
296 print("DEBUG: enabled.\n");
299 #ifdef FAUXCLICKY_ENABLE
301 if (record->event.pressed) {
306 if (record->event.pressed) {
311 if (record->event.pressed) {
316 #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
318 // Split keyboards need to trigger on key-up for edge-case issue
319 #ifndef SPLIT_KEYBOARD
320 if (record->event.pressed) {
322 if (!record->event.pressed) {
325 #ifdef SPLIT_KEYBOARD
330 case RGB_MODE_FORWARD:
331 if (record->event.pressed) {
332 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
334 rgblight_step_reverse();
339 #ifdef SPLIT_KEYBOARD
344 case RGB_MODE_REVERSE:
345 if (record->event.pressed) {
346 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
351 rgblight_step_reverse();
353 #ifdef SPLIT_KEYBOARD
359 // Split keyboards need to trigger on key-up for edge-case issue
360 #ifndef SPLIT_KEYBOARD
361 if (record->event.pressed) {
363 if (!record->event.pressed) {
365 rgblight_increase_hue();
366 #ifdef SPLIT_KEYBOARD
372 // Split keyboards need to trigger on key-up for edge-case issue
373 #ifndef SPLIT_KEYBOARD
374 if (record->event.pressed) {
376 if (!record->event.pressed) {
378 rgblight_decrease_hue();
379 #ifdef SPLIT_KEYBOARD
385 // Split keyboards need to trigger on key-up for edge-case issue
386 #ifndef SPLIT_KEYBOARD
387 if (record->event.pressed) {
389 if (!record->event.pressed) {
391 rgblight_increase_sat();
392 #ifdef SPLIT_KEYBOARD
398 // Split keyboards need to trigger on key-up for edge-case issue
399 #ifndef SPLIT_KEYBOARD
400 if (record->event.pressed) {
402 if (!record->event.pressed) {
404 rgblight_decrease_sat();
405 #ifdef SPLIT_KEYBOARD
411 // Split keyboards need to trigger on key-up for edge-case issue
412 #ifndef SPLIT_KEYBOARD
413 if (record->event.pressed) {
415 if (!record->event.pressed) {
417 rgblight_increase_val();
418 #ifdef SPLIT_KEYBOARD
424 // Split keyboards need to trigger on key-up for edge-case issue
425 #ifndef SPLIT_KEYBOARD
426 if (record->event.pressed) {
428 if (!record->event.pressed) {
430 rgblight_decrease_val();
431 #ifdef SPLIT_KEYBOARD
437 if (record->event.pressed) {
438 rgblight_increase_speed();
442 if (record->event.pressed) {
443 rgblight_decrease_speed();
447 if (record->event.pressed) {
449 #ifdef SPLIT_KEYBOARD
454 case RGB_MODE_BREATHE:
455 if (record->event.pressed) {
456 if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
463 case RGB_MODE_RAINBOW:
464 if (record->event.pressed) {
465 if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
473 if (record->event.pressed) {
474 if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
482 if (record->event.pressed) {
483 if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
490 case RGB_MODE_KNIGHT:
491 if (record->event.pressed) {
492 if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
500 if (record->event.pressed) {
504 case RGB_MODE_GRADIENT:
505 if (record->event.pressed) {
506 if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
513 case RGB_MODE_RGBTEST:
514 if (record->event.pressed) {
518 #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
521 if (record->event.pressed) {
522 set_output(OUTPUT_AUTO);
526 if (record->event.pressed) {
527 set_output(OUTPUT_USB);
530 #ifdef BLUETOOTH_ENABLE
532 if (record->event.pressed) {
533 set_output(OUTPUT_BLUETOOTH);
538 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
539 if (record->event.pressed) {
540 // MAGIC actions (BOOTMAGIC without the boot)
541 if (!eeconfig_is_enabled()) {
545 keymap_config.raw = eeconfig_read_keymap();
548 case MAGIC_SWAP_CONTROL_CAPSLOCK:
549 keymap_config.swap_control_capslock = true;
551 case MAGIC_CAPSLOCK_TO_CONTROL:
552 keymap_config.capslock_to_control = true;
554 case MAGIC_SWAP_LALT_LGUI:
555 keymap_config.swap_lalt_lgui = true;
557 case MAGIC_SWAP_RALT_RGUI:
558 keymap_config.swap_ralt_rgui = true;
561 keymap_config.no_gui = true;
563 case MAGIC_SWAP_GRAVE_ESC:
564 keymap_config.swap_grave_esc = true;
566 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
567 keymap_config.swap_backslash_backspace = true;
569 case MAGIC_HOST_NKRO:
570 keymap_config.nkro = true;
572 case MAGIC_SWAP_ALT_GUI:
573 keymap_config.swap_lalt_lgui = true;
574 keymap_config.swap_ralt_rgui = true;
576 PLAY_SONG(ag_swap_song);
579 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
580 keymap_config.swap_control_capslock = false;
582 case MAGIC_UNCAPSLOCK_TO_CONTROL:
583 keymap_config.capslock_to_control = false;
585 case MAGIC_UNSWAP_LALT_LGUI:
586 keymap_config.swap_lalt_lgui = false;
588 case MAGIC_UNSWAP_RALT_RGUI:
589 keymap_config.swap_ralt_rgui = false;
592 keymap_config.no_gui = false;
594 case MAGIC_UNSWAP_GRAVE_ESC:
595 keymap_config.swap_grave_esc = false;
597 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
598 keymap_config.swap_backslash_backspace = false;
600 case MAGIC_UNHOST_NKRO:
601 keymap_config.nkro = false;
603 case MAGIC_UNSWAP_ALT_GUI:
604 keymap_config.swap_lalt_lgui = false;
605 keymap_config.swap_ralt_rgui = false;
607 PLAY_SONG(ag_norm_song);
610 case MAGIC_TOGGLE_NKRO:
611 keymap_config.nkro = !keymap_config.nkro;
616 eeconfig_update_keymap(keymap_config.raw);
617 clear_keyboard(); // clear to prevent stuck keys
623 if (record->event.pressed) {
624 shift_interrupted[0] = false;
625 scs_timer[0] = timer_read ();
626 register_mods(MOD_BIT(KC_LSFT));
629 #ifdef DISABLE_SPACE_CADET_ROLLOVER
630 if (get_mods() & MOD_BIT(KC_RSFT)) {
631 shift_interrupted[0] = true;
632 shift_interrupted[1] = true;
635 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
636 register_code(LSPO_KEY);
637 unregister_code(LSPO_KEY);
639 unregister_mods(MOD_BIT(KC_LSFT));
645 if (record->event.pressed) {
646 shift_interrupted[1] = false;
647 scs_timer[1] = timer_read ();
648 register_mods(MOD_BIT(KC_RSFT));
651 #ifdef DISABLE_SPACE_CADET_ROLLOVER
652 if (get_mods() & MOD_BIT(KC_LSFT)) {
653 shift_interrupted[0] = true;
654 shift_interrupted[1] = true;
657 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
658 register_code(RSPC_KEY);
659 unregister_code(RSPC_KEY);
661 unregister_mods(MOD_BIT(KC_RSFT));
667 if (record->event.pressed) {
668 shift_interrupted[1] = false;
669 scs_timer[1] = timer_read ();
670 register_mods(MOD_BIT(KC_RSFT));
672 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
673 unregister_mods(MOD_BIT(KC_RSFT));
674 register_code(SFTENT_KEY);
675 unregister_code(SFTENT_KEY);
678 unregister_mods(MOD_BIT(KC_RSFT));
684 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
685 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
687 #ifdef GRAVE_ESC_ALT_OVERRIDE
688 // if ALT is pressed, ESC is always sent
689 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
690 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
695 #ifdef GRAVE_ESC_CTRL_OVERRIDE
696 // if CTRL is pressed, ESC is always sent
697 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
698 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
703 #ifdef GRAVE_ESC_GUI_OVERRIDE
704 // if GUI is pressed, ESC is always sent
705 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
710 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
711 // if SHIFT is pressed, ESC is always sent
712 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
717 if (record->event.pressed) {
718 grave_esc_was_shifted = shifted;
719 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
722 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
725 send_keyboard_report();
729 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
731 if (record->event.pressed)
738 shift_interrupted[0] = true;
739 shift_interrupted[1] = true;
744 return process_action_kb(record);
747 __attribute__ ((weak))
748 const bool ascii_to_shift_lut[0x80] PROGMEM = {
749 0, 0, 0, 0, 0, 0, 0, 0,
750 0, 0, 0, 0, 0, 0, 0, 0,
751 0, 0, 0, 0, 0, 0, 0, 0,
752 0, 0, 0, 0, 0, 0, 0, 0,
753 0, 1, 1, 1, 1, 1, 1, 0,
754 1, 1, 1, 1, 0, 0, 0, 0,
755 0, 0, 0, 0, 0, 0, 0, 0,
756 0, 0, 1, 0, 1, 0, 1, 1,
757 1, 1, 1, 1, 1, 1, 1, 1,
758 1, 1, 1, 1, 1, 1, 1, 1,
759 1, 1, 1, 1, 1, 1, 1, 1,
760 1, 1, 1, 0, 0, 0, 1, 1,
761 0, 0, 0, 0, 0, 0, 0, 0,
762 0, 0, 0, 0, 0, 0, 0, 0,
763 0, 0, 0, 0, 0, 0, 0, 0,
764 0, 0, 0, 1, 1, 1, 1, 0
767 __attribute__ ((weak))
768 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
769 0, 0, 0, 0, 0, 0, 0, 0,
770 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
771 0, 0, 0, 0, 0, 0, 0, 0,
772 0, 0, 0, KC_ESC, 0, 0, 0, 0,
773 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
774 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
775 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
776 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
777 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
778 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
779 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
780 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
781 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
782 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
783 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
784 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
787 void send_string(const char *str) {
788 send_string_with_delay(str, 0);
791 void send_string_P(const char *str) {
792 send_string_with_delay_P(str, 0);
795 void send_string_with_delay(const char *str, uint8_t interval) {
797 char ascii_code = *str;
798 if (!ascii_code) break;
799 if (ascii_code == 1) {
801 uint8_t keycode = *(++str);
802 register_code(keycode);
803 unregister_code(keycode);
804 } else if (ascii_code == 2) {
806 uint8_t keycode = *(++str);
807 register_code(keycode);
808 } else if (ascii_code == 3) {
810 uint8_t keycode = *(++str);
811 unregister_code(keycode);
813 send_char(ascii_code);
817 { uint8_t ms = interval; while (ms--) wait_ms(1); }
821 void send_string_with_delay_P(const char *str, uint8_t interval) {
823 char ascii_code = pgm_read_byte(str);
824 if (!ascii_code) break;
825 if (ascii_code == 1) {
827 uint8_t keycode = pgm_read_byte(++str);
828 register_code(keycode);
829 unregister_code(keycode);
830 } else if (ascii_code == 2) {
832 uint8_t keycode = pgm_read_byte(++str);
833 register_code(keycode);
834 } else if (ascii_code == 3) {
836 uint8_t keycode = pgm_read_byte(++str);
837 unregister_code(keycode);
839 send_char(ascii_code);
843 { uint8_t ms = interval; while (ms--) wait_ms(1); }
847 void send_char(char ascii_code) {
849 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
850 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
851 register_code(KC_LSFT);
852 register_code(keycode);
853 unregister_code(keycode);
854 unregister_code(KC_LSFT);
856 register_code(keycode);
857 unregister_code(keycode);
861 void set_single_persistent_default_layer(uint8_t default_layer) {
862 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
863 PLAY_SONG(default_layer_songs[default_layer]);
865 eeconfig_update_default_layer(1U<<default_layer);
866 default_layer_set(1U<<default_layer);
869 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
870 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
871 uint32_t mask3 = 1UL << layer3;
872 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
875 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
876 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
879 void tap_random_base64(void) {
880 #if defined(__AVR_ATmega32U4__)
881 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
883 uint8_t key = rand() % 64;
887 register_code(KC_LSFT);
888 register_code(key + KC_A);
889 unregister_code(key + KC_A);
890 unregister_code(KC_LSFT);
893 register_code(key - 26 + KC_A);
894 unregister_code(key - 26 + KC_A);
898 unregister_code(KC_0);
901 register_code(key - 53 + KC_1);
902 unregister_code(key - 53 + KC_1);
905 register_code(KC_LSFT);
906 register_code(KC_EQL);
907 unregister_code(KC_EQL);
908 unregister_code(KC_LSFT);
911 register_code(KC_SLSH);
912 unregister_code(KC_SLSH);
917 void matrix_init_quantum() {
918 #ifdef BACKLIGHT_ENABLE
919 backlight_init_ports();
924 #ifdef RGB_MATRIX_ENABLE
930 uint8_t rgb_matrix_task_counter = 0;
932 #ifndef RGB_MATRIX_SKIP_FRAMES
933 #define RGB_MATRIX_SKIP_FRAMES 1
936 void matrix_scan_quantum() {
937 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
941 #ifdef TAP_DANCE_ENABLE
942 matrix_scan_tap_dance();
949 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
953 #ifdef RGB_MATRIX_ENABLE
955 if (rgb_matrix_task_counter == 0) {
956 rgb_matrix_update_pwm_buffers();
958 rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
963 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
965 static const uint8_t backlight_pin = BACKLIGHT_PIN;
967 // depending on the pin, we use a different output compare unit
968 #if BACKLIGHT_PIN == B7
969 # define TCCRxA TCCR1A
970 # define TCCRxB TCCR1B
971 # define COMxx1 COM1C1
974 #elif BACKLIGHT_PIN == B6
975 # define TCCRxA TCCR1A
976 # define TCCRxB TCCR1B
977 # define COMxx1 COM1B1
980 #elif BACKLIGHT_PIN == B5
981 # define TCCRxA TCCR1A
982 # define TCCRxB TCCR1B
983 # define COMxx1 COM1A1
986 #elif BACKLIGHT_PIN == C6
987 # define TCCRxA TCCR3A
988 # define TCCRxB TCCR3B
989 # define COMxx1 COM1A1
993 # define NO_HARDWARE_PWM
996 #ifndef BACKLIGHT_ON_STATE
997 #define BACKLIGHT_ON_STATE 0
1000 #ifdef NO_HARDWARE_PWM // pwm through software
1002 __attribute__ ((weak))
1003 void backlight_init_ports(void)
1005 // Setup backlight pin as output and output to on state.
1007 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1008 #if BACKLIGHT_ON_STATE == 0
1010 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1013 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1017 __attribute__ ((weak))
1018 void backlight_set(uint8_t level) {}
1020 uint8_t backlight_tick = 0;
1022 #ifndef BACKLIGHT_CUSTOM_DRIVER
1023 void backlight_task(void) {
1024 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1025 #if BACKLIGHT_ON_STATE == 0
1027 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1030 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1033 #if BACKLIGHT_ON_STATE == 0
1035 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1038 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1041 backlight_tick = (backlight_tick + 1) % 16;
1045 #ifdef BACKLIGHT_BREATHING
1046 #ifndef BACKLIGHT_CUSTOM_DRIVER
1047 #error "Backlight breathing only available with hardware PWM. Please disable."
1051 #else // pwm through timer
1053 #define TIMER_TOP 0xFFFFU
1055 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1056 static uint16_t cie_lightness(uint16_t v) {
1057 if (v <= 5243) // if below 8% of max
1058 return v / 9; // same as dividing by 900%
1060 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1061 // to get a useful result with integer division, we shift left in the expression above
1062 // and revert what we've done again after squaring.
1064 if (y > 0xFFFFUL) // prevent overflow
1067 return (uint16_t) y;
1071 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1072 static inline void set_pwm(uint16_t val) {
1076 #ifndef BACKLIGHT_CUSTOM_DRIVER
1077 __attribute__ ((weak))
1078 void backlight_set(uint8_t level) {
1079 if (level > BACKLIGHT_LEVELS)
1080 level = BACKLIGHT_LEVELS;
1083 // Turn off PWM control on backlight pin
1084 TCCRxA &= ~(_BV(COMxx1));
1086 // Turn on PWM control of backlight pin
1087 TCCRxA |= _BV(COMxx1);
1089 // Set the brightness
1090 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1093 void backlight_task(void) {}
1094 #endif // BACKLIGHT_CUSTOM_DRIVER
1096 #ifdef BACKLIGHT_BREATHING
1098 #define BREATHING_NO_HALT 0
1099 #define BREATHING_HALT_OFF 1
1100 #define BREATHING_HALT_ON 2
1101 #define BREATHING_STEPS 128
1103 static uint8_t breathing_period = BREATHING_PERIOD;
1104 static uint8_t breathing_halt = BREATHING_NO_HALT;
1105 static uint16_t breathing_counter = 0;
1107 bool is_breathing(void) {
1108 return !!(TIMSK1 & _BV(TOIE1));
1111 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1112 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1113 #define breathing_min() do {breathing_counter = 0;} while (0)
1114 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1116 void breathing_enable(void)
1118 breathing_counter = 0;
1119 breathing_halt = BREATHING_NO_HALT;
1120 breathing_interrupt_enable();
1123 void breathing_pulse(void)
1125 if (get_backlight_level() == 0)
1129 breathing_halt = BREATHING_HALT_ON;
1130 breathing_interrupt_enable();
1133 void breathing_disable(void)
1135 breathing_interrupt_disable();
1136 // Restore backlight level
1137 backlight_set(get_backlight_level());
1140 void breathing_self_disable(void)
1142 if (get_backlight_level() == 0)
1143 breathing_halt = BREATHING_HALT_OFF;
1145 breathing_halt = BREATHING_HALT_ON;
1148 void breathing_toggle(void) {
1150 breathing_disable();
1155 void breathing_period_set(uint8_t value)
1159 breathing_period = value;
1162 void breathing_period_default(void) {
1163 breathing_period_set(BREATHING_PERIOD);
1166 void breathing_period_inc(void)
1168 breathing_period_set(breathing_period+1);
1171 void breathing_period_dec(void)
1173 breathing_period_set(breathing_period-1);
1176 /* To generate breathing curve in python:
1177 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1179 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};
1181 // Use this before the cie_lightness function.
1182 static inline uint16_t scale_backlight(uint16_t v) {
1183 return v / BACKLIGHT_LEVELS * get_backlight_level();
1186 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1187 * about 244 times per second.
1189 ISR(TIMER1_OVF_vect)
1191 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1192 // resetting after one period to prevent ugly reset at overflow.
1193 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1194 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1196 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1197 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1199 breathing_interrupt_disable();
1202 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1205 #endif // BACKLIGHT_BREATHING
1207 __attribute__ ((weak))
1208 void backlight_init_ports(void)
1210 // Setup backlight pin as output and output to on state.
1212 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1213 #if BACKLIGHT_ON_STATE == 0
1215 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1218 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1220 // I could write a wall of text here to explain... but TL;DW
1221 // Go read the ATmega32u4 datasheet.
1222 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1224 // Pin PB7 = OCR1C (Timer 1, Channel C)
1225 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1226 // (i.e. start high, go low when counter matches.)
1227 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1228 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1232 "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 [..]."
1233 "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)."
1235 TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1236 TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1237 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1241 #ifdef BACKLIGHT_BREATHING
1246 #endif // NO_HARDWARE_PWM
1250 __attribute__ ((weak))
1251 void backlight_init_ports(void) {}
1253 __attribute__ ((weak))
1254 void backlight_set(uint8_t level) {}
1258 #ifdef HD44780_ENABLED
1259 #include "hd44780.h"
1263 // Functions for spitting out values
1266 void send_dword(uint32_t number) { // this might not actually work
1267 uint16_t word = (number >> 16);
1269 send_word(number & 0xFFFFUL);
1272 void send_word(uint16_t number) {
1273 uint8_t byte = number >> 8;
1275 send_byte(number & 0xFF);
1278 void send_byte(uint8_t number) {
1279 uint8_t nibble = number >> 4;
1280 send_nibble(nibble);
1281 send_nibble(number & 0xF);
1284 void send_nibble(uint8_t number) {
1287 register_code(KC_0);
1288 unregister_code(KC_0);
1291 register_code(KC_1 + (number - 1));
1292 unregister_code(KC_1 + (number - 1));
1295 register_code(KC_A + (number - 0xA));
1296 unregister_code(KC_A + (number - 0xA));
1302 __attribute__((weak))
1303 uint16_t hex_to_keycode(uint8_t hex)
1308 } else if (hex < 0xA) {
1309 return KC_1 + (hex - 0x1);
1311 return KC_A + (hex - 0xA);
1315 void api_send_unicode(uint32_t unicode) {
1318 dword_to_bytes(unicode, chunk);
1319 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1323 __attribute__ ((weak))
1324 void led_set_user(uint8_t usb_led) {
1328 __attribute__ ((weak))
1329 void led_set_kb(uint8_t usb_led) {
1330 led_set_user(usb_led);
1333 __attribute__ ((weak))
1334 void led_init_ports(void)
1339 __attribute__ ((weak))
1340 void led_set(uint8_t usb_led)
1345 // // Using PE6 Caps Lock LED
1346 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1356 // PORTE &= ~(1<<6);
1359 led_set_kb(usb_led);
1363 //------------------------------------------------------------------------------
1364 // Override these functions in your keymap file to play different tunes on
1365 // different events such as startup and bootloader jump
1367 __attribute__ ((weak))
1368 void startup_user() {}
1370 __attribute__ ((weak))
1371 void shutdown_user() {}
1373 //------------------------------------------------------------------------------