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"
39 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
42 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
45 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
47 float goodbye_song[][2] = GOODBYE_SONG;
48 float ag_norm_song[][2] = AG_NORM_SONG;
49 float ag_swap_song[][2] = AG_SWAP_SONG;
50 #ifdef DEFAULT_LAYER_SONGS
51 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
55 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
57 case QK_MODS ... QK_MODS_MAX:
72 if (code < QK_RMODS_MIN) return;
84 static inline void qk_register_weak_mods(uint8_t kc) {
85 add_weak_mods(MOD_BIT(kc));
86 send_keyboard_report();
89 static inline void qk_unregister_weak_mods(uint8_t kc) {
90 del_weak_mods(MOD_BIT(kc));
91 send_keyboard_report();
94 static inline void qk_register_mods(uint8_t kc) {
95 add_weak_mods(MOD_BIT(kc));
96 send_keyboard_report();
99 static inline void qk_unregister_mods(uint8_t kc) {
100 del_weak_mods(MOD_BIT(kc));
101 send_keyboard_report();
104 void register_code16 (uint16_t code) {
105 if (IS_MOD(code) || code == KC_NO) {
106 do_code16 (code, qk_register_mods);
108 do_code16 (code, qk_register_weak_mods);
110 register_code (code);
113 void unregister_code16 (uint16_t code) {
114 unregister_code (code);
115 if (IS_MOD(code) || code == KC_NO) {
116 do_code16 (code, qk_unregister_mods);
118 do_code16 (code, qk_unregister_weak_mods);
122 __attribute__ ((weak))
123 bool process_action_kb(keyrecord_t *record) {
127 __attribute__ ((weak))
128 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
129 return process_record_user(keycode, record);
132 __attribute__ ((weak))
133 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
137 void reset_keyboard(void) {
139 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
140 process_midi_all_notes_off();
142 #if defined(AUDIO_ENABLE)
143 music_all_notes_off();
144 uint16_t timer_start = timer_read();
145 PLAY_SONG(goodbye_song);
147 while(timer_elapsed(timer_start) < 250)
153 // this is also done later in bootloader.c - not sure if it's neccesary here
154 #ifdef BOOTLOADER_CATERINA
155 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
160 // Shift / paren setup
163 #define LSPO_KEY KC_9
166 #define RSPC_KEY KC_0
169 // Shift / Enter setup
171 #define SFTENT_KEY KC_ENT
174 static bool shift_interrupted[2] = {0, 0};
175 static uint16_t scs_timer[2] = {0, 0};
177 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
178 * Used to ensure that the correct keycode is released if the key is released.
180 static bool grave_esc_was_shifted = false;
182 bool process_record_quantum(keyrecord_t *record) {
184 /* This gets the keycode from the key pressed */
185 keypos_t key = record->event.key;
188 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
189 /* TODO: Use store_or_get_action() or a similar function. */
190 if (!disable_action_cache) {
193 if (record->event.pressed) {
194 layer = layer_switch_get_layer(key);
195 update_source_layers_cache(key, layer);
197 layer = read_source_layers_cache(key);
199 keycode = keymap_key_to_keycode(layer, key);
202 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
204 // This is how you use actions here
205 // if (keycode == KC_LEAD) {
207 // action.code = ACTION_DEFAULT_LAYER_SET(0);
208 // process_action(record, action);
213 #if defined(KEY_LOCK_ENABLE)
214 // Must run first to be able to mask key_up events.
215 process_key_lock(&keycode, record) &&
217 process_record_kb(keycode, record) &&
218 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
219 process_midi(keycode, record) &&
222 process_audio(keycode, record) &&
225 process_steno(keycode, record) &&
227 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
228 process_music(keycode, record) &&
230 #ifdef TAP_DANCE_ENABLE
231 process_tap_dance(keycode, record) &&
233 #ifndef DISABLE_LEADER
234 process_leader(keycode, record) &&
236 #ifndef DISABLE_CHORDING
237 process_chording(keycode, record) &&
240 process_combo(keycode, record) &&
242 #ifdef UNICODE_ENABLE
243 process_unicode(keycode, record) &&
246 process_ucis(keycode, record) &&
248 #ifdef PRINTING_ENABLE
249 process_printer(keycode, record) &&
251 #ifdef AUTO_SHIFT_ENABLE
252 process_auto_shift(keycode, record) &&
254 #ifdef UNICODEMAP_ENABLE
255 process_unicode_map(keycode, record) &&
257 #ifdef TERMINAL_ENABLE
258 process_terminal(keycode, record) &&
264 // Shift / paren setup
268 if (record->event.pressed) {
273 if (record->event.pressed) {
275 print("DEBUG: enabled.\n");
278 #ifdef FAUXCLICKY_ENABLE
280 if (record->event.pressed) {
285 if (record->event.pressed) {
290 if (record->event.pressed) {
295 #ifdef RGBLIGHT_ENABLE
297 if (record->event.pressed) {
301 case RGB_MODE_FORWARD:
302 if (record->event.pressed) {
303 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
305 rgblight_step_reverse();
312 case RGB_MODE_REVERSE:
313 if (record->event.pressed) {
314 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
319 rgblight_step_reverse();
324 if (record->event.pressed) {
325 rgblight_increase_hue();
329 if (record->event.pressed) {
330 rgblight_decrease_hue();
334 if (record->event.pressed) {
335 rgblight_increase_sat();
339 if (record->event.pressed) {
340 rgblight_decrease_sat();
344 if (record->event.pressed) {
345 rgblight_increase_val();
349 if (record->event.pressed) {
350 rgblight_decrease_val();
354 if (record->event.pressed) {
358 case RGB_MODE_BREATHE:
359 if (record->event.pressed) {
360 if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
367 case RGB_MODE_RAINBOW:
368 if (record->event.pressed) {
369 if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
377 if (record->event.pressed) {
378 if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
386 if (record->event.pressed) {
387 if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
394 case RGB_MODE_KNIGHT:
395 if (record->event.pressed) {
396 if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
404 if (record->event.pressed) {
408 case RGB_MODE_GRADIENT:
409 if (record->event.pressed) {
410 if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
420 if (record->event.pressed) {
421 set_output(OUTPUT_AUTO);
425 if (record->event.pressed) {
426 set_output(OUTPUT_USB);
429 #ifdef BLUETOOTH_ENABLE
431 if (record->event.pressed) {
432 set_output(OUTPUT_BLUETOOTH);
437 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
438 if (record->event.pressed) {
439 // MAGIC actions (BOOTMAGIC without the boot)
440 if (!eeconfig_is_enabled()) {
444 keymap_config.raw = eeconfig_read_keymap();
447 case MAGIC_SWAP_CONTROL_CAPSLOCK:
448 keymap_config.swap_control_capslock = true;
450 case MAGIC_CAPSLOCK_TO_CONTROL:
451 keymap_config.capslock_to_control = true;
453 case MAGIC_SWAP_LALT_LGUI:
454 keymap_config.swap_lalt_lgui = true;
456 case MAGIC_SWAP_RALT_RGUI:
457 keymap_config.swap_ralt_rgui = true;
460 keymap_config.no_gui = true;
462 case MAGIC_SWAP_GRAVE_ESC:
463 keymap_config.swap_grave_esc = true;
465 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
466 keymap_config.swap_backslash_backspace = true;
468 case MAGIC_HOST_NKRO:
469 keymap_config.nkro = true;
471 case MAGIC_SWAP_ALT_GUI:
472 keymap_config.swap_lalt_lgui = true;
473 keymap_config.swap_ralt_rgui = true;
475 PLAY_SONG(ag_swap_song);
478 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
479 keymap_config.swap_control_capslock = false;
481 case MAGIC_UNCAPSLOCK_TO_CONTROL:
482 keymap_config.capslock_to_control = false;
484 case MAGIC_UNSWAP_LALT_LGUI:
485 keymap_config.swap_lalt_lgui = false;
487 case MAGIC_UNSWAP_RALT_RGUI:
488 keymap_config.swap_ralt_rgui = false;
491 keymap_config.no_gui = false;
493 case MAGIC_UNSWAP_GRAVE_ESC:
494 keymap_config.swap_grave_esc = false;
496 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
497 keymap_config.swap_backslash_backspace = false;
499 case MAGIC_UNHOST_NKRO:
500 keymap_config.nkro = false;
502 case MAGIC_UNSWAP_ALT_GUI:
503 keymap_config.swap_lalt_lgui = false;
504 keymap_config.swap_ralt_rgui = false;
506 PLAY_SONG(ag_norm_song);
509 case MAGIC_TOGGLE_NKRO:
510 keymap_config.nkro = !keymap_config.nkro;
515 eeconfig_update_keymap(keymap_config.raw);
516 clear_keyboard(); // clear to prevent stuck keys
522 if (record->event.pressed) {
523 shift_interrupted[0] = false;
524 scs_timer[0] = timer_read ();
525 register_mods(MOD_BIT(KC_LSFT));
528 #ifdef DISABLE_SPACE_CADET_ROLLOVER
529 if (get_mods() & MOD_BIT(KC_RSFT)) {
530 shift_interrupted[0] = true;
531 shift_interrupted[1] = true;
534 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
535 register_code(LSPO_KEY);
536 unregister_code(LSPO_KEY);
538 unregister_mods(MOD_BIT(KC_LSFT));
544 if (record->event.pressed) {
545 shift_interrupted[1] = false;
546 scs_timer[1] = timer_read ();
547 register_mods(MOD_BIT(KC_RSFT));
550 #ifdef DISABLE_SPACE_CADET_ROLLOVER
551 if (get_mods() & MOD_BIT(KC_LSFT)) {
552 shift_interrupted[0] = true;
553 shift_interrupted[1] = true;
556 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
557 register_code(RSPC_KEY);
558 unregister_code(RSPC_KEY);
560 unregister_mods(MOD_BIT(KC_RSFT));
566 if (record->event.pressed) {
567 shift_interrupted[1] = false;
568 scs_timer[1] = timer_read ();
569 register_mods(MOD_BIT(KC_RSFT));
571 else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
572 unregister_mods(MOD_BIT(KC_RSFT));
573 register_code(SFTENT_KEY);
574 unregister_code(SFTENT_KEY);
577 unregister_mods(MOD_BIT(KC_RSFT));
583 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
584 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
586 #ifdef GRAVE_ESC_ALT_OVERRIDE
587 // if ALT is pressed, ESC is always sent
588 // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
589 if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
594 #ifdef GRAVE_ESC_CTRL_OVERRIDE
595 // if CTRL is pressed, ESC is always sent
596 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
597 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
602 #ifdef GRAVE_ESC_GUI_OVERRIDE
603 // if GUI is pressed, ESC is always sent
604 if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
609 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
610 // if SHIFT is pressed, ESC is always sent
611 if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
616 if (record->event.pressed) {
617 grave_esc_was_shifted = shifted;
618 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
621 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
624 send_keyboard_report();
628 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
630 if (record->event.pressed)
637 shift_interrupted[0] = true;
638 shift_interrupted[1] = true;
643 return process_action_kb(record);
646 __attribute__ ((weak))
647 const bool ascii_to_shift_lut[0x80] PROGMEM = {
648 0, 0, 0, 0, 0, 0, 0, 0,
649 0, 0, 0, 0, 0, 0, 0, 0,
650 0, 0, 0, 0, 0, 0, 0, 0,
651 0, 0, 0, 0, 0, 0, 0, 0,
652 0, 1, 1, 1, 1, 1, 1, 0,
653 1, 1, 1, 1, 0, 0, 0, 0,
654 0, 0, 0, 0, 0, 0, 0, 0,
655 0, 0, 1, 0, 1, 0, 1, 1,
656 1, 1, 1, 1, 1, 1, 1, 1,
657 1, 1, 1, 1, 1, 1, 1, 1,
658 1, 1, 1, 1, 1, 1, 1, 1,
659 1, 1, 1, 0, 0, 0, 1, 1,
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, 1, 1, 1, 1, 0
666 __attribute__ ((weak))
667 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
668 0, 0, 0, 0, 0, 0, 0, 0,
669 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
670 0, 0, 0, 0, 0, 0, 0, 0,
671 0, 0, 0, KC_ESC, 0, 0, 0, 0,
672 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
673 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
674 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
675 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
676 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
677 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
678 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
679 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
680 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
681 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
682 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
683 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
686 void send_string(const char *str) {
687 send_string_with_delay(str, 0);
690 void send_string_P(const char *str) {
691 send_string_with_delay_P(str, 0);
694 void send_string_with_delay(const char *str, uint8_t interval) {
696 char ascii_code = *str;
697 if (!ascii_code) break;
698 if (ascii_code == 1) {
700 uint8_t keycode = *(++str);
701 register_code(keycode);
702 unregister_code(keycode);
703 } else if (ascii_code == 2) {
705 uint8_t keycode = *(++str);
706 register_code(keycode);
707 } else if (ascii_code == 3) {
709 uint8_t keycode = *(++str);
710 unregister_code(keycode);
712 send_char(ascii_code);
716 { uint8_t ms = interval; while (ms--) wait_ms(1); }
720 void send_string_with_delay_P(const char *str, uint8_t interval) {
722 char ascii_code = pgm_read_byte(str);
723 if (!ascii_code) break;
724 if (ascii_code == 1) {
726 uint8_t keycode = pgm_read_byte(++str);
727 register_code(keycode);
728 unregister_code(keycode);
729 } else if (ascii_code == 2) {
731 uint8_t keycode = pgm_read_byte(++str);
732 register_code(keycode);
733 } else if (ascii_code == 3) {
735 uint8_t keycode = pgm_read_byte(++str);
736 unregister_code(keycode);
738 send_char(ascii_code);
742 { uint8_t ms = interval; while (ms--) wait_ms(1); }
746 void send_char(char ascii_code) {
748 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
749 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
750 register_code(KC_LSFT);
751 register_code(keycode);
752 unregister_code(keycode);
753 unregister_code(KC_LSFT);
755 register_code(keycode);
756 unregister_code(keycode);
760 void set_single_persistent_default_layer(uint8_t default_layer) {
761 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
762 PLAY_SONG(default_layer_songs[default_layer]);
764 eeconfig_update_default_layer(1U<<default_layer);
765 default_layer_set(1U<<default_layer);
768 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
769 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
776 void tap_random_base64(void) {
777 #if defined(__AVR_ATmega32U4__)
778 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
780 uint8_t key = rand() % 64;
784 register_code(KC_LSFT);
785 register_code(key + KC_A);
786 unregister_code(key + KC_A);
787 unregister_code(KC_LSFT);
790 register_code(key - 26 + KC_A);
791 unregister_code(key - 26 + KC_A);
795 unregister_code(KC_0);
798 register_code(key - 53 + KC_1);
799 unregister_code(key - 53 + KC_1);
802 register_code(KC_LSFT);
803 register_code(KC_EQL);
804 unregister_code(KC_EQL);
805 unregister_code(KC_LSFT);
808 register_code(KC_SLSH);
809 unregister_code(KC_SLSH);
814 void matrix_init_quantum() {
815 #ifdef BACKLIGHT_ENABLE
816 backlight_init_ports();
824 void matrix_scan_quantum() {
829 #ifdef TAP_DANCE_ENABLE
830 matrix_scan_tap_dance();
837 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
844 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
846 static const uint8_t backlight_pin = BACKLIGHT_PIN;
848 // depending on the pin, we use a different output compare unit
849 #if BACKLIGHT_PIN == B7
850 # define COM1x1 COM1C1
852 #elif BACKLIGHT_PIN == B6
853 # define COM1x1 COM1B1
855 #elif BACKLIGHT_PIN == B5
856 # define COM1x1 COM1A1
859 # define NO_HARDWARE_PWM
862 #ifndef BACKLIGHT_ON_STATE
863 #define BACKLIGHT_ON_STATE 0
866 #ifdef NO_HARDWARE_PWM // pwm through software
868 __attribute__ ((weak))
869 void backlight_init_ports(void)
871 // Setup backlight pin as output and output to on state.
873 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
874 #if BACKLIGHT_ON_STATE == 0
876 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
879 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
883 __attribute__ ((weak))
884 void backlight_set(uint8_t level) {}
886 uint8_t backlight_tick = 0;
888 #ifndef BACKLIGHT_CUSTOM_DRIVER
889 void backlight_task(void) {
890 if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
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);
899 #if BACKLIGHT_ON_STATE == 0
901 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
904 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
907 backlight_tick = (backlight_tick + 1) % 16;
911 #ifdef BACKLIGHT_BREATHING
912 #ifndef BACKLIGHT_CUSTOM_DRIVER
913 #error "Backlight breathing only available with hardware PWM. Please disable."
917 #else // pwm through timer
919 #define TIMER_TOP 0xFFFFU
921 // See http://jared.geek.nz/2013/feb/linear-led-pwm
922 static uint16_t cie_lightness(uint16_t v) {
923 if (v <= 5243) // if below 8% of max
924 return v / 9; // same as dividing by 900%
926 uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
927 // to get a useful result with integer division, we shift left in the expression above
928 // and revert what we've done again after squaring.
930 if (y > 0xFFFFUL) // prevent overflow
937 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
938 static inline void set_pwm(uint16_t val) {
942 #ifndef BACKLIGHT_CUSTOM_DRIVER
943 __attribute__ ((weak))
944 void backlight_set(uint8_t level) {
945 if (level > BACKLIGHT_LEVELS)
946 level = BACKLIGHT_LEVELS;
949 // Turn off PWM control on backlight pin
950 TCCR1A &= ~(_BV(COM1x1));
952 // Turn on PWM control of backlight pin
953 TCCR1A |= _BV(COM1x1);
955 // Set the brightness
956 set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
959 void backlight_task(void) {}
960 #endif // BACKLIGHT_CUSTOM_DRIVER
962 #ifdef BACKLIGHT_BREATHING
964 #define BREATHING_NO_HALT 0
965 #define BREATHING_HALT_OFF 1
966 #define BREATHING_HALT_ON 2
967 #define BREATHING_STEPS 128
969 static uint8_t breathing_period = BREATHING_PERIOD;
970 static uint8_t breathing_halt = BREATHING_NO_HALT;
971 static uint16_t breathing_counter = 0;
973 bool is_breathing(void) {
974 return !!(TIMSK1 & _BV(TOIE1));
977 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
978 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
979 #define breathing_min() do {breathing_counter = 0;} while (0)
980 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
982 void breathing_enable(void)
984 breathing_counter = 0;
985 breathing_halt = BREATHING_NO_HALT;
986 breathing_interrupt_enable();
989 void breathing_pulse(void)
991 if (get_backlight_level() == 0)
995 breathing_halt = BREATHING_HALT_ON;
996 breathing_interrupt_enable();
999 void breathing_disable(void)
1001 breathing_interrupt_disable();
1002 // Restore backlight level
1003 backlight_set(get_backlight_level());
1006 void breathing_self_disable(void)
1008 if (get_backlight_level() == 0)
1009 breathing_halt = BREATHING_HALT_OFF;
1011 breathing_halt = BREATHING_HALT_ON;
1014 void breathing_toggle(void) {
1016 breathing_disable();
1021 void breathing_period_set(uint8_t value)
1025 breathing_period = value;
1028 void breathing_period_default(void) {
1029 breathing_period_set(BREATHING_PERIOD);
1032 void breathing_period_inc(void)
1034 breathing_period_set(breathing_period+1);
1037 void breathing_period_dec(void)
1039 breathing_period_set(breathing_period-1);
1042 /* To generate breathing curve in python:
1043 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1045 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};
1047 // Use this before the cie_lightness function.
1048 static inline uint16_t scale_backlight(uint16_t v) {
1049 return v / BACKLIGHT_LEVELS * get_backlight_level();
1052 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1053 * about 244 times per second.
1055 ISR(TIMER1_OVF_vect)
1057 uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1058 // resetting after one period to prevent ugly reset at overflow.
1059 breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1060 uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1062 if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1063 ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1065 breathing_interrupt_disable();
1068 set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1071 #endif // BACKLIGHT_BREATHING
1073 __attribute__ ((weak))
1074 void backlight_init_ports(void)
1076 // Setup backlight pin as output and output to on state.
1078 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1079 #if BACKLIGHT_ON_STATE == 0
1081 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1084 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1086 // I could write a wall of text here to explain... but TL;DW
1087 // Go read the ATmega32u4 datasheet.
1088 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1090 // Pin PB7 = OCR1C (Timer 1, Channel C)
1091 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1092 // (i.e. start high, go low when counter matches.)
1093 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1094 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1098 "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 [..]."
1099 "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)."
1102 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
1103 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1104 // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1108 #ifdef BACKLIGHT_BREATHING
1113 #endif // NO_HARDWARE_PWM
1117 __attribute__ ((weak))
1118 void backlight_init_ports(void) {}
1120 __attribute__ ((weak))
1121 void backlight_set(uint8_t level) {}
1126 // Functions for spitting out values
1129 void send_dword(uint32_t number) { // this might not actually work
1130 uint16_t word = (number >> 16);
1132 send_word(number & 0xFFFFUL);
1135 void send_word(uint16_t number) {
1136 uint8_t byte = number >> 8;
1138 send_byte(number & 0xFF);
1141 void send_byte(uint8_t number) {
1142 uint8_t nibble = number >> 4;
1143 send_nibble(nibble);
1144 send_nibble(number & 0xF);
1147 void send_nibble(uint8_t number) {
1150 register_code(KC_0);
1151 unregister_code(KC_0);
1154 register_code(KC_1 + (number - 1));
1155 unregister_code(KC_1 + (number - 1));
1158 register_code(KC_A + (number - 0xA));
1159 unregister_code(KC_A + (number - 0xA));
1165 __attribute__((weak))
1166 uint16_t hex_to_keycode(uint8_t hex)
1171 } else if (hex < 0xA) {
1172 return KC_1 + (hex - 0x1);
1174 return KC_A + (hex - 0xA);
1178 void api_send_unicode(uint32_t unicode) {
1181 dword_to_bytes(unicode, chunk);
1182 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1186 __attribute__ ((weak))
1187 void led_set_user(uint8_t usb_led) {
1191 __attribute__ ((weak))
1192 void led_set_kb(uint8_t usb_led) {
1193 led_set_user(usb_led);
1196 __attribute__ ((weak))
1197 void led_init_ports(void)
1202 __attribute__ ((weak))
1203 void led_set(uint8_t usb_led)
1208 // // Using PE6 Caps Lock LED
1209 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1219 // PORTE &= ~(1<<6);
1222 led_set_kb(usb_led);
1226 //------------------------------------------------------------------------------
1227 // Override these functions in your keymap file to play different tunes on
1228 // different events such as startup and bootloader jump
1230 __attribute__ ((weak))
1231 void startup_user() {}
1233 __attribute__ ((weak))
1234 void shutdown_user() {}
1236 //------------------------------------------------------------------------------