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)
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 process_record_kb(keycode, record) &&
230 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
231 process_midi(keycode, record) &&
234 process_audio(keycode, record) &&
237 process_steno(keycode, record) &&
239 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
240 process_music(keycode, record) &&
242 #ifdef TAP_DANCE_ENABLE
243 process_tap_dance(keycode, record) &&
245 #ifndef DISABLE_LEADER
246 process_leader(keycode, record) &&
248 #ifndef DISABLE_CHORDING
249 process_chording(keycode, record) &&
252 process_combo(keycode, record) &&
254 #ifdef UNICODE_ENABLE
255 process_unicode(keycode, record) &&
258 process_ucis(keycode, record) &&
260 #ifdef PRINTING_ENABLE
261 process_printer(keycode, record) &&
263 #ifdef AUTO_SHIFT_ENABLE
264 process_auto_shift(keycode, record) &&
266 #ifdef UNICODEMAP_ENABLE
267 process_unicode_map(keycode, record) &&
269 #ifdef TERMINAL_ENABLE
270 process_terminal(keycode, record) &&
276 // Shift / paren setup
280 if (record->event.pressed) {
285 if (record->event.pressed) {
287 print("DEBUG: enabled.\n");
290 #ifdef FAUXCLICKY_ENABLE
292 if (record->event.pressed) {
297 if (record->event.pressed) {
302 if (record->event.pressed) {
307 #ifdef RGBLIGHT_ENABLE
309 if (record->event.pressed) {
313 case RGB_MODE_FORWARD:
314 if (record->event.pressed) {
315 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
317 rgblight_step_reverse();
324 case RGB_MODE_REVERSE:
325 if (record->event.pressed) {
326 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
331 rgblight_step_reverse();
336 if (record->event.pressed) {
337 rgblight_increase_hue();
341 if (record->event.pressed) {
342 rgblight_decrease_hue();
346 if (record->event.pressed) {
347 rgblight_increase_sat();
351 if (record->event.pressed) {
352 rgblight_decrease_sat();
356 if (record->event.pressed) {
357 rgblight_increase_val();
361 if (record->event.pressed) {
362 rgblight_decrease_val();
366 if (record->event.pressed) {
370 case RGB_MODE_BREATHE:
371 if (record->event.pressed) {
372 if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
379 case RGB_MODE_RAINBOW:
380 if (record->event.pressed) {
381 if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
389 if (record->event.pressed) {
390 if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
398 if (record->event.pressed) {
399 if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
406 case RGB_MODE_KNIGHT:
407 if (record->event.pressed) {
408 if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
416 if (record->event.pressed) {
420 case RGB_MODE_GRADIENT:
421 if (record->event.pressed) {
422 if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
432 if (record->event.pressed) {
433 set_output(OUTPUT_AUTO);
437 if (record->event.pressed) {
438 set_output(OUTPUT_USB);
441 #ifdef BLUETOOTH_ENABLE
443 if (record->event.pressed) {
444 set_output(OUTPUT_BLUETOOTH);
449 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
450 if (record->event.pressed) {
451 // MAGIC actions (BOOTMAGIC without the boot)
452 if (!eeconfig_is_enabled()) {
456 keymap_config.raw = eeconfig_read_keymap();
459 case MAGIC_SWAP_CONTROL_CAPSLOCK:
460 keymap_config.swap_control_capslock = true;
462 case MAGIC_CAPSLOCK_TO_CONTROL:
463 keymap_config.capslock_to_control = true;
465 case MAGIC_SWAP_LALT_LGUI:
466 keymap_config.swap_lalt_lgui = true;
468 case MAGIC_SWAP_RALT_RGUI:
469 keymap_config.swap_ralt_rgui = true;
472 keymap_config.no_gui = true;
474 case MAGIC_SWAP_GRAVE_ESC:
475 keymap_config.swap_grave_esc = true;
477 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
478 keymap_config.swap_backslash_backspace = true;
480 case MAGIC_HOST_NKRO:
481 keymap_config.nkro = true;
483 case MAGIC_SWAP_ALT_GUI:
484 keymap_config.swap_lalt_lgui = true;
485 keymap_config.swap_ralt_rgui = true;
487 PLAY_SONG(ag_swap_song);
490 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
491 keymap_config.swap_control_capslock = false;
493 case MAGIC_UNCAPSLOCK_TO_CONTROL:
494 keymap_config.capslock_to_control = false;
496 case MAGIC_UNSWAP_LALT_LGUI:
497 keymap_config.swap_lalt_lgui = false;
499 case MAGIC_UNSWAP_RALT_RGUI:
500 keymap_config.swap_ralt_rgui = false;
503 keymap_config.no_gui = false;
505 case MAGIC_UNSWAP_GRAVE_ESC:
506 keymap_config.swap_grave_esc = false;
508 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
509 keymap_config.swap_backslash_backspace = false;
511 case MAGIC_UNHOST_NKRO:
512 keymap_config.nkro = false;
514 case MAGIC_UNSWAP_ALT_GUI:
515 keymap_config.swap_lalt_lgui = false;
516 keymap_config.swap_ralt_rgui = false;
518 PLAY_SONG(ag_norm_song);
521 case MAGIC_TOGGLE_NKRO:
522 keymap_config.nkro = !keymap_config.nkro;
527 eeconfig_update_keymap(keymap_config.raw);
528 clear_keyboard(); // clear to prevent stuck keys
534 if (record->event.pressed) {
535 shift_interrupted[0] = false;
536 scs_timer[0] = timer_read ();
537 register_mods(MOD_BIT(KC_LSFT));
540 #ifdef DISABLE_SPACE_CADET_ROLLOVER
541 if (get_mods() & MOD_BIT(KC_RSFT)) {
542 shift_interrupted[0] = true;
543 shift_interrupted[1] = true;
546 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
547 register_code(LSPO_KEY);
548 unregister_code(LSPO_KEY);
550 unregister_mods(MOD_BIT(KC_LSFT));
556 if (record->event.pressed) {
557 shift_interrupted[1] = false;
558 scs_timer[1] = timer_read ();
559 register_mods(MOD_BIT(KC_RSFT));
562 #ifdef DISABLE_SPACE_CADET_ROLLOVER
563 if (get_mods() & MOD_BIT(KC_LSFT)) {
564 shift_interrupted[0] = true;
565 shift_interrupted[1] = true;
568 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
569 register_code(RSPC_KEY);
570 unregister_code(RSPC_KEY);
572 unregister_mods(MOD_BIT(KC_RSFT));
578 if (record->event.pressed) {
579 shift_interrupted[1] = false;
580 scs_timer[1] = timer_read ();
581 register_mods(MOD_BIT(KC_RSFT));
583 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
584 unregister_mods(MOD_BIT(KC_RSFT));
585 register_code(SFTENT_KEY);
586 unregister_code(SFTENT_KEY);
589 unregister_mods(MOD_BIT(KC_RSFT));
595 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
596 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
598 #ifdef GRAVE_ESC_ALT_OVERRIDE
599 // if ALT is pressed, ESC is always sent
600 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
601 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
606 #ifdef GRAVE_ESC_CTRL_OVERRIDE
607 // if CTRL is pressed, ESC is always sent
608 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
609 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
614 #ifdef GRAVE_ESC_GUI_OVERRIDE
615 // if GUI is pressed, ESC is always sent
616 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
621 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
622 // if SHIFT is pressed, ESC is always sent
623 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
628 if (record->event.pressed) {
629 grave_esc_was_shifted = shifted;
630 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
633 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
636 send_keyboard_report();
640 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
642 if (record->event.pressed)
649 shift_interrupted[0] = true;
650 shift_interrupted[1] = true;
655 return process_action_kb(record);
658 __attribute__ ((weak))
659 const bool ascii_to_shift_lut[0x80] PROGMEM = {
660 0, 0, 0, 0, 0, 0, 0, 0,
661 0, 0, 0, 0, 0, 0, 0, 0,
662 0, 0, 0, 0, 0, 0, 0, 0,
663 0, 0, 0, 0, 0, 0, 0, 0,
664 0, 1, 1, 1, 1, 1, 1, 0,
665 1, 1, 1, 1, 0, 0, 0, 0,
666 0, 0, 0, 0, 0, 0, 0, 0,
667 0, 0, 1, 0, 1, 0, 1, 1,
668 1, 1, 1, 1, 1, 1, 1, 1,
669 1, 1, 1, 1, 1, 1, 1, 1,
670 1, 1, 1, 1, 1, 1, 1, 1,
671 1, 1, 1, 0, 0, 0, 1, 1,
672 0, 0, 0, 0, 0, 0, 0, 0,
673 0, 0, 0, 0, 0, 0, 0, 0,
674 0, 0, 0, 0, 0, 0, 0, 0,
675 0, 0, 0, 1, 1, 1, 1, 0
678 __attribute__ ((weak))
679 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
680 0, 0, 0, 0, 0, 0, 0, 0,
681 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
682 0, 0, 0, 0, 0, 0, 0, 0,
683 0, 0, 0, KC_ESC, 0, 0, 0, 0,
684 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
685 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
686 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
687 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
688 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
689 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
690 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
691 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
692 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
693 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
694 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
695 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
698 void send_string(const char *str) {
699 send_string_with_delay(str, 0);
702 void send_string_P(const char *str) {
703 send_string_with_delay_P(str, 0);
706 void send_string_with_delay(const char *str, uint8_t interval) {
708 char ascii_code = *str;
709 if (!ascii_code) break;
710 if (ascii_code == 1) {
712 uint8_t keycode = *(++str);
713 register_code(keycode);
714 unregister_code(keycode);
715 } else if (ascii_code == 2) {
717 uint8_t keycode = *(++str);
718 register_code(keycode);
719 } else if (ascii_code == 3) {
721 uint8_t keycode = *(++str);
722 unregister_code(keycode);
724 send_char(ascii_code);
728 { uint8_t ms = interval; while (ms--) wait_ms(1); }
732 void send_string_with_delay_P(const char *str, uint8_t interval) {
734 char ascii_code = pgm_read_byte(str);
735 if (!ascii_code) break;
736 if (ascii_code == 1) {
738 uint8_t keycode = pgm_read_byte(++str);
739 register_code(keycode);
740 unregister_code(keycode);
741 } else if (ascii_code == 2) {
743 uint8_t keycode = pgm_read_byte(++str);
744 register_code(keycode);
745 } else if (ascii_code == 3) {
747 uint8_t keycode = pgm_read_byte(++str);
748 unregister_code(keycode);
750 send_char(ascii_code);
754 { uint8_t ms = interval; while (ms--) wait_ms(1); }
758 void send_char(char ascii_code) {
760 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
761 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
762 register_code(KC_LSFT);
763 register_code(keycode);
764 unregister_code(keycode);
765 unregister_code(KC_LSFT);
767 register_code(keycode);
768 unregister_code(keycode);
772 void set_single_persistent_default_layer(uint8_t default_layer) {
773 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
774 PLAY_SONG(default_layer_songs[default_layer]);
776 eeconfig_update_default_layer(1U<<default_layer);
777 default_layer_set(1U<<default_layer);
780 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
781 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
788 void tap_random_base64(void) {
789 #if defined(__AVR_ATmega32U4__)
790 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
792 uint8_t key = rand() % 64;
796 register_code(KC_LSFT);
797 register_code(key + KC_A);
798 unregister_code(key + KC_A);
799 unregister_code(KC_LSFT);
802 register_code(key - 26 + KC_A);
803 unregister_code(key - 26 + KC_A);
807 unregister_code(KC_0);
810 register_code(key - 53 + KC_1);
811 unregister_code(key - 53 + KC_1);
814 register_code(KC_LSFT);
815 register_code(KC_EQL);
816 unregister_code(KC_EQL);
817 unregister_code(KC_LSFT);
820 register_code(KC_SLSH);
821 unregister_code(KC_SLSH);
826 void matrix_init_quantum() {
827 #ifdef BACKLIGHT_ENABLE
828 backlight_init_ports();
836 void matrix_scan_quantum() {
841 #ifdef TAP_DANCE_ENABLE
842 matrix_scan_tap_dance();
849 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
856 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
858 static const uint8_t backlight_pin = BACKLIGHT_PIN;
860 // depending on the pin, we use a different output compare unit
861 #if BACKLIGHT_PIN == B7
862 # define COM1x1 COM1C1
864 #elif BACKLIGHT_PIN == B6
865 # define COM1x1 COM1B1
867 #elif BACKLIGHT_PIN == B5
868 # define COM1x1 COM1A1
871 # define NO_HARDWARE_PWM
874 #ifndef BACKLIGHT_ON_STATE
875 #define BACKLIGHT_ON_STATE 0
878 #ifdef NO_HARDWARE_PWM // pwm through software
880 __attribute__ ((weak))
881 void backlight_init_ports(void)
883 // Setup backlight pin as output and output to on state.
885 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
886 #if BACKLIGHT_ON_STATE == 0
888 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
891 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
895 __attribute__ ((weak))
896 void backlight_set(uint8_t level) {}
898 uint8_t backlight_tick = 0;
900 #ifndef BACKLIGHT_CUSTOM_DRIVER
901 void backlight_task(void) {
902 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
903 #if BACKLIGHT_ON_STATE == 0
905 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
908 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
911 #if BACKLIGHT_ON_STATE == 0
913 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
916 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
919 backlight_tick = (backlight_tick + 1) % 16;
923 #ifdef BACKLIGHT_BREATHING
924 #ifndef BACKLIGHT_CUSTOM_DRIVER
925 #error "Backlight breathing only available with hardware PWM. Please disable."
929 #else // pwm through timer
931 #define TIMER_TOP 0xFFFFU
933 // See http://jared.geek.nz/2013/feb/linear-led-pwm
934 static uint16_t cie_lightness(uint16_t v) {
935 if (v <= 5243) // if below 8% of max
936 return v / 9; // same as dividing by 900%
938 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
939 // to get a useful result with integer division, we shift left in the expression above
940 // and revert what we've done again after squaring.
942 if (y > 0xFFFFUL) // prevent overflow
949 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
950 static inline void set_pwm(uint16_t val) {
954 #ifndef BACKLIGHT_CUSTOM_DRIVER
955 __attribute__ ((weak))
956 void backlight_set(uint8_t level) {
957 if (level > BACKLIGHT_LEVELS)
958 level = BACKLIGHT_LEVELS;
961 // Turn off PWM control on backlight pin
962 TCCR1A &= ~(_BV(COM1x1));
964 // Turn on PWM control of backlight pin
965 TCCR1A |= _BV(COM1x1);
967 // Set the brightness
968 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
971 void backlight_task(void) {}
972 #endif // BACKLIGHT_CUSTOM_DRIVER
974 #ifdef BACKLIGHT_BREATHING
976 #define BREATHING_NO_HALT 0
977 #define BREATHING_HALT_OFF 1
978 #define BREATHING_HALT_ON 2
979 #define BREATHING_STEPS 128
981 static uint8_t breathing_period = BREATHING_PERIOD;
982 static uint8_t breathing_halt = BREATHING_NO_HALT;
983 static uint16_t breathing_counter = 0;
985 bool is_breathing(void) {
986 return !!(TIMSK1 & _BV(TOIE1));
989 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
990 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
991 #define breathing_min() do {breathing_counter = 0;} while (0)
992 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
994 void breathing_enable(void)
996 breathing_counter = 0;
997 breathing_halt = BREATHING_NO_HALT;
998 breathing_interrupt_enable();
1001 void breathing_pulse(void)
1003 if (get_backlight_level() == 0)
1007 breathing_halt = BREATHING_HALT_ON;
1008 breathing_interrupt_enable();
1011 void breathing_disable(void)
1013 breathing_interrupt_disable();
1014 // Restore backlight level
1015 backlight_set(get_backlight_level());
1018 void breathing_self_disable(void)
1020 if (get_backlight_level() == 0)
1021 breathing_halt = BREATHING_HALT_OFF;
1023 breathing_halt = BREATHING_HALT_ON;
1026 void breathing_toggle(void) {
1028 breathing_disable();
1033 void breathing_period_set(uint8_t value)
1037 breathing_period = value;
1040 void breathing_period_default(void) {
1041 breathing_period_set(BREATHING_PERIOD);
1044 void breathing_period_inc(void)
1046 breathing_period_set(breathing_period+1);
1049 void breathing_period_dec(void)
1051 breathing_period_set(breathing_period-1);
1054 /* To generate breathing curve in python:
1055 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1057 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};
1059 // Use this before the cie_lightness function.
1060 static inline uint16_t scale_backlight(uint16_t v) {
1061 return v / BACKLIGHT_LEVELS * get_backlight_level();
1064 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1065 * about 244 times per second.
1067 ISR(TIMER1_OVF_vect)
1069 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1070 // resetting after one period to prevent ugly reset at overflow.
1071 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1072 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1074 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1075 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1077 breathing_interrupt_disable();
1080 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1083 #endif // BACKLIGHT_BREATHING
1085 __attribute__ ((weak))
1086 void backlight_init_ports(void)
1088 // Setup backlight pin as output and output to on state.
1090 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1091 #if BACKLIGHT_ON_STATE == 0
1093 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1096 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1098 // I could write a wall of text here to explain... but TL;DW
1099 // Go read the ATmega32u4 datasheet.
1100 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1102 // Pin PB7 = OCR1C (Timer 1, Channel C)
1103 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1104 // (i.e. start high, go low when counter matches.)
1105 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1106 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1110 "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 [..]."
1111 "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)."
1114 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
1115 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1116 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1120 #ifdef BACKLIGHT_BREATHING
1125 #endif // NO_HARDWARE_PWM
1129 __attribute__ ((weak))
1130 void backlight_init_ports(void) {}
1132 __attribute__ ((weak))
1133 void backlight_set(uint8_t level) {}
1138 // Functions for spitting out values
1141 void send_dword(uint32_t number) { // this might not actually work
1142 uint16_t word = (number >> 16);
1144 send_word(number & 0xFFFFUL);
1147 void send_word(uint16_t number) {
1148 uint8_t byte = number >> 8;
1150 send_byte(number & 0xFF);
1153 void send_byte(uint8_t number) {
1154 uint8_t nibble = number >> 4;
1155 send_nibble(nibble);
1156 send_nibble(number & 0xF);
1159 void send_nibble(uint8_t number) {
1162 register_code(KC_0);
1163 unregister_code(KC_0);
1166 register_code(KC_1 + (number - 1));
1167 unregister_code(KC_1 + (number - 1));
1170 register_code(KC_A + (number - 0xA));
1171 unregister_code(KC_A + (number - 0xA));
1177 __attribute__((weak))
1178 uint16_t hex_to_keycode(uint8_t hex)
1183 } else if (hex < 0xA) {
1184 return KC_1 + (hex - 0x1);
1186 return KC_A + (hex - 0xA);
1190 void api_send_unicode(uint32_t unicode) {
1193 dword_to_bytes(unicode, chunk);
1194 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1198 __attribute__ ((weak))
1199 void led_set_user(uint8_t usb_led) {
1203 __attribute__ ((weak))
1204 void led_set_kb(uint8_t usb_led) {
1205 led_set_user(usb_led);
1208 __attribute__ ((weak))
1209 void led_init_ports(void)
1214 __attribute__ ((weak))
1215 void led_set(uint8_t usb_led)
1220 // // Using PE6 Caps Lock LED
1221 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1231 // PORTE &= ~(1<<6);
1234 led_set_kb(usb_led);
1238 //------------------------------------------------------------------------------
1239 // Override these functions in your keymap file to play different tunes on
1240 // different events such as startup and bootloader jump
1242 __attribute__ ((weak))
1243 void startup_user() {}
1245 __attribute__ ((weak))
1246 void shutdown_user() {}
1248 //------------------------------------------------------------------------------