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();
150 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
151 music_all_notes_off();
152 uint16_t timer_start = timer_read();
153 PLAY_SONG(goodbye_song);
155 while(timer_elapsed(timer_start) < 250)
161 // this is also done later in bootloader.c - not sure if it's neccesary here
162 #ifdef BOOTLOADER_CATERINA
163 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
168 // Shift / paren setup
171 #define LSPO_KEY KC_9
174 #define RSPC_KEY KC_0
177 // Shift / Enter setup
179 #define SFTENT_KEY KC_ENT
182 static bool shift_interrupted[2] = {0, 0};
183 static uint16_t scs_timer[2] = {0, 0};
185 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
186 * Used to ensure that the correct keycode is released if the key is released.
188 static bool grave_esc_was_shifted = false;
190 bool process_record_quantum(keyrecord_t *record) {
192 /* This gets the keycode from the key pressed */
193 keypos_t key = record->event.key;
196 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
197 /* TODO: Use store_or_get_action() or a similar function. */
198 if (!disable_action_cache) {
201 if (record->event.pressed) {
202 layer = layer_switch_get_layer(key);
203 update_source_layers_cache(key, layer);
205 layer = read_source_layers_cache(key);
207 keycode = keymap_key_to_keycode(layer, key);
210 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
212 // This is how you use actions here
213 // if (keycode == KC_LEAD) {
215 // action.code = ACTION_DEFAULT_LAYER_SET(0);
216 // process_action(record, action);
220 #ifdef TAP_DANCE_ENABLE
221 preprocess_tap_dance(keycode, record);
225 #if defined(KEY_LOCK_ENABLE)
226 // Must run first to be able to mask key_up events.
227 process_key_lock(&keycode, record) &&
229 #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
230 process_clicky(keycode, record) &&
231 #endif //AUDIO_CLICKY
232 process_record_kb(keycode, record) &&
233 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
234 process_midi(keycode, record) &&
237 process_audio(keycode, record) &&
240 process_steno(keycode, record) &&
242 #if ( defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
243 process_music(keycode, record) &&
245 #ifdef TAP_DANCE_ENABLE
246 process_tap_dance(keycode, record) &&
248 #ifndef DISABLE_LEADER
249 process_leader(keycode, record) &&
251 #ifndef DISABLE_CHORDING
252 process_chording(keycode, record) &&
255 process_combo(keycode, record) &&
257 #ifdef UNICODE_ENABLE
258 process_unicode(keycode, record) &&
261 process_ucis(keycode, record) &&
263 #ifdef PRINTING_ENABLE
264 process_printer(keycode, record) &&
266 #ifdef AUTO_SHIFT_ENABLE
267 process_auto_shift(keycode, record) &&
269 #ifdef UNICODEMAP_ENABLE
270 process_unicode_map(keycode, record) &&
272 #ifdef TERMINAL_ENABLE
273 process_terminal(keycode, record) &&
279 // Shift / paren setup
283 if (record->event.pressed) {
288 if (record->event.pressed) {
290 print("DEBUG: enabled.\n");
293 #ifdef FAUXCLICKY_ENABLE
295 if (record->event.pressed) {
300 if (record->event.pressed) {
305 if (record->event.pressed) {
310 #ifdef RGBLIGHT_ENABLE
312 if (record->event.pressed) {
316 case RGB_MODE_FORWARD:
317 if (record->event.pressed) {
318 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
320 rgblight_step_reverse();
327 case RGB_MODE_REVERSE:
328 if (record->event.pressed) {
329 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
334 rgblight_step_reverse();
339 if (record->event.pressed) {
340 rgblight_increase_hue();
344 if (record->event.pressed) {
345 rgblight_decrease_hue();
349 if (record->event.pressed) {
350 rgblight_increase_sat();
354 if (record->event.pressed) {
355 rgblight_decrease_sat();
359 if (record->event.pressed) {
360 rgblight_increase_val();
364 if (record->event.pressed) {
365 rgblight_decrease_val();
369 if (record->event.pressed) {
373 case RGB_MODE_BREATHE:
374 if (record->event.pressed) {
375 if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
382 case RGB_MODE_RAINBOW:
383 if (record->event.pressed) {
384 if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
392 if (record->event.pressed) {
393 if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
401 if (record->event.pressed) {
402 if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
409 case RGB_MODE_KNIGHT:
410 if (record->event.pressed) {
411 if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
419 if (record->event.pressed) {
423 case RGB_MODE_GRADIENT:
424 if (record->event.pressed) {
425 if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
435 if (record->event.pressed) {
436 set_output(OUTPUT_AUTO);
440 if (record->event.pressed) {
441 set_output(OUTPUT_USB);
444 #ifdef BLUETOOTH_ENABLE
446 if (record->event.pressed) {
447 set_output(OUTPUT_BLUETOOTH);
452 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
453 if (record->event.pressed) {
454 // MAGIC actions (BOOTMAGIC without the boot)
455 if (!eeconfig_is_enabled()) {
459 keymap_config.raw = eeconfig_read_keymap();
462 case MAGIC_SWAP_CONTROL_CAPSLOCK:
463 keymap_config.swap_control_capslock = true;
465 case MAGIC_CAPSLOCK_TO_CONTROL:
466 keymap_config.capslock_to_control = true;
468 case MAGIC_SWAP_LALT_LGUI:
469 keymap_config.swap_lalt_lgui = true;
471 case MAGIC_SWAP_RALT_RGUI:
472 keymap_config.swap_ralt_rgui = true;
475 keymap_config.no_gui = true;
477 case MAGIC_SWAP_GRAVE_ESC:
478 keymap_config.swap_grave_esc = true;
480 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
481 keymap_config.swap_backslash_backspace = true;
483 case MAGIC_HOST_NKRO:
484 keymap_config.nkro = true;
486 case MAGIC_SWAP_ALT_GUI:
487 keymap_config.swap_lalt_lgui = true;
488 keymap_config.swap_ralt_rgui = true;
490 PLAY_SONG(ag_swap_song);
493 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
494 keymap_config.swap_control_capslock = false;
496 case MAGIC_UNCAPSLOCK_TO_CONTROL:
497 keymap_config.capslock_to_control = false;
499 case MAGIC_UNSWAP_LALT_LGUI:
500 keymap_config.swap_lalt_lgui = false;
502 case MAGIC_UNSWAP_RALT_RGUI:
503 keymap_config.swap_ralt_rgui = false;
506 keymap_config.no_gui = false;
508 case MAGIC_UNSWAP_GRAVE_ESC:
509 keymap_config.swap_grave_esc = false;
511 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
512 keymap_config.swap_backslash_backspace = false;
514 case MAGIC_UNHOST_NKRO:
515 keymap_config.nkro = false;
517 case MAGIC_UNSWAP_ALT_GUI:
518 keymap_config.swap_lalt_lgui = false;
519 keymap_config.swap_ralt_rgui = false;
521 PLAY_SONG(ag_norm_song);
524 case MAGIC_TOGGLE_NKRO:
525 keymap_config.nkro = !keymap_config.nkro;
530 eeconfig_update_keymap(keymap_config.raw);
531 clear_keyboard(); // clear to prevent stuck keys
537 if (record->event.pressed) {
538 shift_interrupted[0] = false;
539 scs_timer[0] = timer_read ();
540 register_mods(MOD_BIT(KC_LSFT));
543 #ifdef DISABLE_SPACE_CADET_ROLLOVER
544 if (get_mods() & MOD_BIT(KC_RSFT)) {
545 shift_interrupted[0] = true;
546 shift_interrupted[1] = true;
549 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
550 register_code(LSPO_KEY);
551 unregister_code(LSPO_KEY);
553 unregister_mods(MOD_BIT(KC_LSFT));
559 if (record->event.pressed) {
560 shift_interrupted[1] = false;
561 scs_timer[1] = timer_read ();
562 register_mods(MOD_BIT(KC_RSFT));
565 #ifdef DISABLE_SPACE_CADET_ROLLOVER
566 if (get_mods() & MOD_BIT(KC_LSFT)) {
567 shift_interrupted[0] = true;
568 shift_interrupted[1] = true;
571 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
572 register_code(RSPC_KEY);
573 unregister_code(RSPC_KEY);
575 unregister_mods(MOD_BIT(KC_RSFT));
581 if (record->event.pressed) {
582 shift_interrupted[1] = false;
583 scs_timer[1] = timer_read ();
584 register_mods(MOD_BIT(KC_RSFT));
586 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
587 unregister_mods(MOD_BIT(KC_RSFT));
588 register_code(SFTENT_KEY);
589 unregister_code(SFTENT_KEY);
592 unregister_mods(MOD_BIT(KC_RSFT));
598 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
599 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
601 #ifdef GRAVE_ESC_ALT_OVERRIDE
602 // if ALT is pressed, ESC is always sent
603 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
604 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
609 #ifdef GRAVE_ESC_CTRL_OVERRIDE
610 // if CTRL is pressed, ESC is always sent
611 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
612 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
617 #ifdef GRAVE_ESC_GUI_OVERRIDE
618 // if GUI is pressed, ESC is always sent
619 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
624 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
625 // if SHIFT is pressed, ESC is always sent
626 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
631 if (record->event.pressed) {
632 grave_esc_was_shifted = shifted;
633 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
636 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
639 send_keyboard_report();
643 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
645 if (record->event.pressed)
652 shift_interrupted[0] = true;
653 shift_interrupted[1] = true;
658 return process_action_kb(record);
661 __attribute__ ((weak))
662 const bool ascii_to_shift_lut[0x80] PROGMEM = {
663 0, 0, 0, 0, 0, 0, 0, 0,
664 0, 0, 0, 0, 0, 0, 0, 0,
665 0, 0, 0, 0, 0, 0, 0, 0,
666 0, 0, 0, 0, 0, 0, 0, 0,
667 0, 1, 1, 1, 1, 1, 1, 0,
668 1, 1, 1, 1, 0, 0, 0, 0,
669 0, 0, 0, 0, 0, 0, 0, 0,
670 0, 0, 1, 0, 1, 0, 1, 1,
671 1, 1, 1, 1, 1, 1, 1, 1,
672 1, 1, 1, 1, 1, 1, 1, 1,
673 1, 1, 1, 1, 1, 1, 1, 1,
674 1, 1, 1, 0, 0, 0, 1, 1,
675 0, 0, 0, 0, 0, 0, 0, 0,
676 0, 0, 0, 0, 0, 0, 0, 0,
677 0, 0, 0, 0, 0, 0, 0, 0,
678 0, 0, 0, 1, 1, 1, 1, 0
681 __attribute__ ((weak))
682 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
683 0, 0, 0, 0, 0, 0, 0, 0,
684 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
685 0, 0, 0, 0, 0, 0, 0, 0,
686 0, 0, 0, KC_ESC, 0, 0, 0, 0,
687 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
688 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
689 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
690 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
691 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
692 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
693 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
694 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
695 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
696 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
697 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
698 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
701 void send_string(const char *str) {
702 send_string_with_delay(str, 0);
705 void send_string_P(const char *str) {
706 send_string_with_delay_P(str, 0);
709 void send_string_with_delay(const char *str, uint8_t interval) {
711 char ascii_code = *str;
712 if (!ascii_code) break;
713 if (ascii_code == 1) {
715 uint8_t keycode = *(++str);
716 register_code(keycode);
717 unregister_code(keycode);
718 } else if (ascii_code == 2) {
720 uint8_t keycode = *(++str);
721 register_code(keycode);
722 } else if (ascii_code == 3) {
724 uint8_t keycode = *(++str);
725 unregister_code(keycode);
727 send_char(ascii_code);
731 { uint8_t ms = interval; while (ms--) wait_ms(1); }
735 void send_string_with_delay_P(const char *str, uint8_t interval) {
737 char ascii_code = pgm_read_byte(str);
738 if (!ascii_code) break;
739 if (ascii_code == 1) {
741 uint8_t keycode = pgm_read_byte(++str);
742 register_code(keycode);
743 unregister_code(keycode);
744 } else if (ascii_code == 2) {
746 uint8_t keycode = pgm_read_byte(++str);
747 register_code(keycode);
748 } else if (ascii_code == 3) {
750 uint8_t keycode = pgm_read_byte(++str);
751 unregister_code(keycode);
753 send_char(ascii_code);
757 { uint8_t ms = interval; while (ms--) wait_ms(1); }
761 void send_char(char ascii_code) {
763 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
764 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
765 register_code(KC_LSFT);
766 register_code(keycode);
767 unregister_code(keycode);
768 unregister_code(KC_LSFT);
770 register_code(keycode);
771 unregister_code(keycode);
775 void set_single_persistent_default_layer(uint8_t default_layer) {
776 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
777 PLAY_SONG(default_layer_songs[default_layer]);
779 eeconfig_update_default_layer(1U<<default_layer);
780 default_layer_set(1U<<default_layer);
783 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
784 uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
785 uint32_t mask3 = 1UL << layer3;
786 return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
789 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
790 layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
793 void tap_random_base64(void) {
794 #if defined(__AVR_ATmega32U4__)
795 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
797 uint8_t key = rand() % 64;
801 register_code(KC_LSFT);
802 register_code(key + KC_A);
803 unregister_code(key + KC_A);
804 unregister_code(KC_LSFT);
807 register_code(key - 26 + KC_A);
808 unregister_code(key - 26 + KC_A);
812 unregister_code(KC_0);
815 register_code(key - 53 + KC_1);
816 unregister_code(key - 53 + KC_1);
819 register_code(KC_LSFT);
820 register_code(KC_EQL);
821 unregister_code(KC_EQL);
822 unregister_code(KC_LSFT);
825 register_code(KC_SLSH);
826 unregister_code(KC_SLSH);
831 void matrix_init_quantum() {
832 #ifdef BACKLIGHT_ENABLE
833 backlight_init_ports();
841 void matrix_scan_quantum() {
842 #if defined(AUDIO_ENABLE)
846 #ifdef TAP_DANCE_ENABLE
847 matrix_scan_tap_dance();
854 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
861 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
863 static const uint8_t backlight_pin = BACKLIGHT_PIN;
865 // depending on the pin, we use a different output compare unit
866 #if BACKLIGHT_PIN == B7
867 # define COM1x1 COM1C1
869 #elif BACKLIGHT_PIN == B6
870 # define COM1x1 COM1B1
872 #elif BACKLIGHT_PIN == B5
873 # define COM1x1 COM1A1
876 # define NO_HARDWARE_PWM
879 #ifndef BACKLIGHT_ON_STATE
880 #define BACKLIGHT_ON_STATE 0
883 #ifdef NO_HARDWARE_PWM // pwm through software
885 __attribute__ ((weak))
886 void backlight_init_ports(void)
888 // Setup backlight pin as output and output to on state.
890 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
891 #if BACKLIGHT_ON_STATE == 0
893 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
896 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
900 __attribute__ ((weak))
901 void backlight_set(uint8_t level) {}
903 uint8_t backlight_tick = 0;
905 #ifndef BACKLIGHT_CUSTOM_DRIVER
906 void backlight_task(void) {
907 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
908 #if BACKLIGHT_ON_STATE == 0
910 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
913 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
916 #if BACKLIGHT_ON_STATE == 0
918 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
921 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
924 backlight_tick = (backlight_tick + 1) % 16;
928 #ifdef BACKLIGHT_BREATHING
929 #ifndef BACKLIGHT_CUSTOM_DRIVER
930 #error "Backlight breathing only available with hardware PWM. Please disable."
934 #else // pwm through timer
936 #define TIMER_TOP 0xFFFFU
938 // See http://jared.geek.nz/2013/feb/linear-led-pwm
939 static uint16_t cie_lightness(uint16_t v) {
940 if (v <= 5243) // if below 8% of max
941 return v / 9; // same as dividing by 900%
943 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
944 // to get a useful result with integer division, we shift left in the expression above
945 // and revert what we've done again after squaring.
947 if (y > 0xFFFFUL) // prevent overflow
954 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
955 static inline void set_pwm(uint16_t val) {
959 #ifndef BACKLIGHT_CUSTOM_DRIVER
960 __attribute__ ((weak))
961 void backlight_set(uint8_t level) {
962 if (level > BACKLIGHT_LEVELS)
963 level = BACKLIGHT_LEVELS;
966 // Turn off PWM control on backlight pin
967 TCCR1A &= ~(_BV(COM1x1));
969 // Turn on PWM control of backlight pin
970 TCCR1A |= _BV(COM1x1);
972 // Set the brightness
973 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
976 void backlight_task(void) {}
977 #endif // BACKLIGHT_CUSTOM_DRIVER
979 #ifdef BACKLIGHT_BREATHING
981 #define BREATHING_NO_HALT 0
982 #define BREATHING_HALT_OFF 1
983 #define BREATHING_HALT_ON 2
984 #define BREATHING_STEPS 128
986 static uint8_t breathing_period = BREATHING_PERIOD;
987 static uint8_t breathing_halt = BREATHING_NO_HALT;
988 static uint16_t breathing_counter = 0;
990 bool is_breathing(void) {
991 return !!(TIMSK1 & _BV(TOIE1));
994 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
995 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
996 #define breathing_min() do {breathing_counter = 0;} while (0)
997 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
999 void breathing_enable(void)
1001 breathing_counter = 0;
1002 breathing_halt = BREATHING_NO_HALT;
1003 breathing_interrupt_enable();
1006 void breathing_pulse(void)
1008 if (get_backlight_level() == 0)
1012 breathing_halt = BREATHING_HALT_ON;
1013 breathing_interrupt_enable();
1016 void breathing_disable(void)
1018 breathing_interrupt_disable();
1019 // Restore backlight level
1020 backlight_set(get_backlight_level());
1023 void breathing_self_disable(void)
1025 if (get_backlight_level() == 0)
1026 breathing_halt = BREATHING_HALT_OFF;
1028 breathing_halt = BREATHING_HALT_ON;
1031 void breathing_toggle(void) {
1033 breathing_disable();
1038 void breathing_period_set(uint8_t value)
1042 breathing_period = value;
1045 void breathing_period_default(void) {
1046 breathing_period_set(BREATHING_PERIOD);
1049 void breathing_period_inc(void)
1051 breathing_period_set(breathing_period+1);
1054 void breathing_period_dec(void)
1056 breathing_period_set(breathing_period-1);
1059 /* To generate breathing curve in python:
1060 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1062 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};
1064 // Use this before the cie_lightness function.
1065 static inline uint16_t scale_backlight(uint16_t v) {
1066 return v / BACKLIGHT_LEVELS * get_backlight_level();
1069 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1070 * about 244 times per second.
1072 ISR(TIMER1_OVF_vect)
1074 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1075 // resetting after one period to prevent ugly reset at overflow.
1076 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1077 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1079 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1080 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1082 breathing_interrupt_disable();
1085 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1088 #endif // BACKLIGHT_BREATHING
1090 __attribute__ ((weak))
1091 void backlight_init_ports(void)
1093 // Setup backlight pin as output and output to on state.
1095 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1096 #if BACKLIGHT_ON_STATE == 0
1098 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1101 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1103 // I could write a wall of text here to explain... but TL;DW
1104 // Go read the ATmega32u4 datasheet.
1105 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1107 // Pin PB7 = OCR1C (Timer 1, Channel C)
1108 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1109 // (i.e. start high, go low when counter matches.)
1110 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1111 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1115 "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 [..]."
1116 "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)."
1119 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
1120 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1121 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1125 #ifdef BACKLIGHT_BREATHING
1130 #endif // NO_HARDWARE_PWM
1134 __attribute__ ((weak))
1135 void backlight_init_ports(void) {}
1137 __attribute__ ((weak))
1138 void backlight_set(uint8_t level) {}
1143 // Functions for spitting out values
1146 void send_dword(uint32_t number) { // this might not actually work
1147 uint16_t word = (number >> 16);
1149 send_word(number & 0xFFFFUL);
1152 void send_word(uint16_t number) {
1153 uint8_t byte = number >> 8;
1155 send_byte(number & 0xFF);
1158 void send_byte(uint8_t number) {
1159 uint8_t nibble = number >> 4;
1160 send_nibble(nibble);
1161 send_nibble(number & 0xF);
1164 void send_nibble(uint8_t number) {
1167 register_code(KC_0);
1168 unregister_code(KC_0);
1171 register_code(KC_1 + (number - 1));
1172 unregister_code(KC_1 + (number - 1));
1175 register_code(KC_A + (number - 0xA));
1176 unregister_code(KC_A + (number - 0xA));
1182 __attribute__((weak))
1183 uint16_t hex_to_keycode(uint8_t hex)
1188 } else if (hex < 0xA) {
1189 return KC_1 + (hex - 0x1);
1191 return KC_A + (hex - 0xA);
1195 void api_send_unicode(uint32_t unicode) {
1198 dword_to_bytes(unicode, chunk);
1199 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1203 __attribute__ ((weak))
1204 void led_set_user(uint8_t usb_led) {
1208 __attribute__ ((weak))
1209 void led_set_kb(uint8_t usb_led) {
1210 led_set_user(usb_led);
1213 __attribute__ ((weak))
1214 void led_init_ports(void)
1219 __attribute__ ((weak))
1220 void led_set(uint8_t usb_led)
1225 // // Using PE6 Caps Lock LED
1226 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1236 // PORTE &= ~(1<<6);
1239 led_set_kb(usb_led);
1243 //------------------------------------------------------------------------------
1244 // Override these functions in your keymap file to play different tunes on
1245 // different events such as startup and bootloader jump
1247 __attribute__ ((weak))
1248 void startup_user() {}
1250 __attribute__ ((weak))
1251 void shutdown_user() {}
1253 //------------------------------------------------------------------------------