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 #include "backlight.h"
27 extern backlight_config_t backlight_config;
29 #ifdef FAUXCLICKY_ENABLE
30 #include "fauxclicky.h"
35 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
38 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
41 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
43 float goodbye_song[][2] = GOODBYE_SONG;
44 float ag_norm_song[][2] = AG_NORM_SONG;
45 float ag_swap_song[][2] = AG_SWAP_SONG;
46 #ifdef DEFAULT_LAYER_SONGS
47 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
51 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
53 case QK_MODS ... QK_MODS_MAX:
68 if (code < QK_RMODS_MIN) return;
80 static inline void qk_register_weak_mods(uint8_t kc) {
81 add_weak_mods(MOD_BIT(kc));
82 send_keyboard_report();
85 static inline void qk_unregister_weak_mods(uint8_t kc) {
86 del_weak_mods(MOD_BIT(kc));
87 send_keyboard_report();
90 static inline void qk_register_mods(uint8_t kc) {
91 add_weak_mods(MOD_BIT(kc));
92 send_keyboard_report();
95 static inline void qk_unregister_mods(uint8_t kc) {
96 del_weak_mods(MOD_BIT(kc));
97 send_keyboard_report();
100 void register_code16 (uint16_t code) {
101 if (IS_MOD(code) || code == KC_NO) {
102 do_code16 (code, qk_register_mods);
104 do_code16 (code, qk_register_weak_mods);
106 register_code (code);
109 void unregister_code16 (uint16_t code) {
110 unregister_code (code);
111 if (IS_MOD(code) || code == KC_NO) {
112 do_code16 (code, qk_unregister_mods);
114 do_code16 (code, qk_unregister_weak_mods);
118 __attribute__ ((weak))
119 bool process_action_kb(keyrecord_t *record) {
123 __attribute__ ((weak))
124 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
125 return process_record_user(keycode, record);
128 __attribute__ ((weak))
129 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
133 void reset_keyboard(void) {
135 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
136 music_all_notes_off();
137 uint16_t timer_start = timer_read();
138 PLAY_SONG(goodbye_song);
140 while(timer_elapsed(timer_start) < 250)
146 // this is also done later in bootloader.c - not sure if it's neccesary here
147 #ifdef BOOTLOADER_CATERINA
148 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
153 // Shift / paren setup
156 #define LSPO_KEY KC_9
159 #define RSPC_KEY KC_0
162 static bool shift_interrupted[2] = {0, 0};
163 static uint16_t scs_timer[2] = {0, 0};
165 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
166 * Used to ensure that the correct keycode is released if the key is released.
168 static bool grave_esc_was_shifted = false;
170 bool process_record_quantum(keyrecord_t *record) {
172 /* This gets the keycode from the key pressed */
173 keypos_t key = record->event.key;
176 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
177 /* TODO: Use store_or_get_action() or a similar function. */
178 if (!disable_action_cache) {
181 if (record->event.pressed) {
182 layer = layer_switch_get_layer(key);
183 update_source_layers_cache(key, layer);
185 layer = read_source_layers_cache(key);
187 keycode = keymap_key_to_keycode(layer, key);
190 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
192 // This is how you use actions here
193 // if (keycode == KC_LEAD) {
195 // action.code = ACTION_DEFAULT_LAYER_SET(0);
196 // process_action(record, action);
201 #if defined(KEY_LOCK_ENABLE)
202 // Must run first to be able to mask key_up events.
203 process_key_lock(&keycode, record) &&
205 process_record_kb(keycode, record) &&
206 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
207 process_midi(keycode, record) &&
210 process_audio(keycode, record) &&
213 process_steno(keycode, record) &&
215 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
216 process_music(keycode, record) &&
218 #ifdef TAP_DANCE_ENABLE
219 process_tap_dance(keycode, record) &&
221 #ifndef DISABLE_LEADER
222 process_leader(keycode, record) &&
224 #ifndef DISABLE_CHORDING
225 process_chording(keycode, record) &&
228 process_combo(keycode, record) &&
230 #ifdef UNICODE_ENABLE
231 process_unicode(keycode, record) &&
234 process_ucis(keycode, record) &&
236 #ifdef PRINTING_ENABLE
237 process_printer(keycode, record) &&
239 #ifdef AUTO_SHIFT_ENABLE
240 process_auto_shift(keycode, record) &&
242 #ifdef UNICODEMAP_ENABLE
243 process_unicode_map(keycode, record) &&
245 #ifdef TERMINAL_ENABLE
246 process_terminal(keycode, record) &&
252 // Shift / paren setup
256 if (record->event.pressed) {
261 if (record->event.pressed) {
263 print("DEBUG: enabled.\n");
266 #ifdef FAUXCLICKY_ENABLE
268 if (record->event.pressed) {
273 if (record->event.pressed) {
278 if (record->event.pressed) {
283 #ifdef RGBLIGHT_ENABLE
285 if (record->event.pressed) {
290 if (record->event.pressed) {
295 // same as RBG_MOD, but if shift is pressed, it will use the reverese direction instead.
296 if (record->event.pressed) {
297 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
299 rgblight_step_reverse();
307 if (record->event.pressed) {
308 rgblight_increase_hue();
312 if (record->event.pressed) {
313 rgblight_decrease_hue();
317 if (record->event.pressed) {
318 rgblight_increase_sat();
322 if (record->event.pressed) {
323 rgblight_decrease_sat();
327 if (record->event.pressed) {
328 rgblight_increase_val();
332 if (record->event.pressed) {
333 rgblight_decrease_val();
337 if (record->event.pressed) {
341 case RGB_MODE_BREATHE:
342 if (record->event.pressed) {
343 if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
350 case RGB_MODE_RAINBOW:
351 if (record->event.pressed) {
352 if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
360 if (record->event.pressed) {
361 if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
369 if (record->event.pressed) {
370 if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
377 case RGB_MODE_KNIGHT:
378 if (record->event.pressed) {
379 if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
387 if (record->event.pressed) {
391 case RGB_MODE_GRADIENT:
392 if (record->event.pressed) {
393 if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
403 if (record->event.pressed) {
404 set_output(OUTPUT_AUTO);
408 if (record->event.pressed) {
409 set_output(OUTPUT_USB);
412 #ifdef BLUETOOTH_ENABLE
414 if (record->event.pressed) {
415 set_output(OUTPUT_BLUETOOTH);
420 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
421 if (record->event.pressed) {
422 // MAGIC actions (BOOTMAGIC without the boot)
423 if (!eeconfig_is_enabled()) {
427 keymap_config.raw = eeconfig_read_keymap();
430 case MAGIC_SWAP_CONTROL_CAPSLOCK:
431 keymap_config.swap_control_capslock = true;
433 case MAGIC_CAPSLOCK_TO_CONTROL:
434 keymap_config.capslock_to_control = true;
436 case MAGIC_SWAP_LALT_LGUI:
437 keymap_config.swap_lalt_lgui = true;
439 case MAGIC_SWAP_RALT_RGUI:
440 keymap_config.swap_ralt_rgui = true;
443 keymap_config.no_gui = true;
445 case MAGIC_SWAP_GRAVE_ESC:
446 keymap_config.swap_grave_esc = true;
448 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
449 keymap_config.swap_backslash_backspace = true;
451 case MAGIC_HOST_NKRO:
452 keymap_config.nkro = true;
454 case MAGIC_SWAP_ALT_GUI:
455 keymap_config.swap_lalt_lgui = true;
456 keymap_config.swap_ralt_rgui = true;
458 PLAY_SONG(ag_swap_song);
461 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
462 keymap_config.swap_control_capslock = false;
464 case MAGIC_UNCAPSLOCK_TO_CONTROL:
465 keymap_config.capslock_to_control = false;
467 case MAGIC_UNSWAP_LALT_LGUI:
468 keymap_config.swap_lalt_lgui = false;
470 case MAGIC_UNSWAP_RALT_RGUI:
471 keymap_config.swap_ralt_rgui = false;
474 keymap_config.no_gui = false;
476 case MAGIC_UNSWAP_GRAVE_ESC:
477 keymap_config.swap_grave_esc = false;
479 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
480 keymap_config.swap_backslash_backspace = false;
482 case MAGIC_UNHOST_NKRO:
483 keymap_config.nkro = false;
485 case MAGIC_UNSWAP_ALT_GUI:
486 keymap_config.swap_lalt_lgui = false;
487 keymap_config.swap_ralt_rgui = false;
489 PLAY_SONG(ag_norm_song);
492 case MAGIC_TOGGLE_NKRO:
493 keymap_config.nkro = !keymap_config.nkro;
498 eeconfig_update_keymap(keymap_config.raw);
499 clear_keyboard(); // clear to prevent stuck keys
505 if (record->event.pressed) {
506 shift_interrupted[0] = false;
507 scs_timer[0] = timer_read ();
508 register_mods(MOD_BIT(KC_LSFT));
511 #ifdef DISABLE_SPACE_CADET_ROLLOVER
512 if (get_mods() & MOD_BIT(KC_RSFT)) {
513 shift_interrupted[0] = true;
514 shift_interrupted[1] = true;
517 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
518 register_code(LSPO_KEY);
519 unregister_code(LSPO_KEY);
521 unregister_mods(MOD_BIT(KC_LSFT));
527 if (record->event.pressed) {
528 shift_interrupted[1] = false;
529 scs_timer[1] = timer_read ();
530 register_mods(MOD_BIT(KC_RSFT));
533 #ifdef DISABLE_SPACE_CADET_ROLLOVER
534 if (get_mods() & MOD_BIT(KC_LSFT)) {
535 shift_interrupted[0] = true;
536 shift_interrupted[1] = true;
539 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
540 register_code(RSPC_KEY);
541 unregister_code(RSPC_KEY);
543 unregister_mods(MOD_BIT(KC_RSFT));
548 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
549 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
551 #ifdef GRAVE_ESC_CTRL_OVERRIDE
552 // if CTRL is pressed, ESC is always read as ESC, even if SHIFT or GUI is pressed.
553 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
554 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL)))
558 if (record->event.pressed) {
559 grave_esc_was_shifted = shifted;
560 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
563 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
566 send_keyboard_report();
569 shift_interrupted[0] = true;
570 shift_interrupted[1] = true;
575 return process_action_kb(record);
578 __attribute__ ((weak))
579 const bool ascii_to_shift_lut[0x80] PROGMEM = {
580 0, 0, 0, 0, 0, 0, 0, 0,
581 0, 0, 0, 0, 0, 0, 0, 0,
582 0, 0, 0, 0, 0, 0, 0, 0,
583 0, 0, 0, 0, 0, 0, 0, 0,
584 0, 1, 1, 1, 1, 1, 1, 0,
585 1, 1, 1, 1, 0, 0, 0, 0,
586 0, 0, 0, 0, 0, 0, 0, 0,
587 0, 0, 1, 0, 1, 0, 1, 1,
588 1, 1, 1, 1, 1, 1, 1, 1,
589 1, 1, 1, 1, 1, 1, 1, 1,
590 1, 1, 1, 1, 1, 1, 1, 1,
591 1, 1, 1, 0, 0, 0, 1, 1,
592 0, 0, 0, 0, 0, 0, 0, 0,
593 0, 0, 0, 0, 0, 0, 0, 0,
594 0, 0, 0, 0, 0, 0, 0, 0,
595 0, 0, 0, 1, 1, 1, 1, 0
598 __attribute__ ((weak))
599 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
600 0, 0, 0, 0, 0, 0, 0, 0,
601 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
602 0, 0, 0, 0, 0, 0, 0, 0,
603 0, 0, 0, KC_ESC, 0, 0, 0, 0,
604 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
605 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
606 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
607 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
608 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
609 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
610 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
611 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
612 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
613 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
614 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
615 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
618 void send_string(const char *str) {
619 send_string_with_delay(str, 0);
622 void send_string_P(const char *str) {
623 send_string_with_delay_P(str, 0);
626 void send_string_with_delay(const char *str, uint8_t interval) {
628 char ascii_code = *str;
629 if (!ascii_code) break;
630 if (ascii_code == 1) {
632 uint8_t keycode = *(++str);
633 register_code(keycode);
634 unregister_code(keycode);
635 } else if (ascii_code == 2) {
637 uint8_t keycode = *(++str);
638 register_code(keycode);
639 } else if (ascii_code == 3) {
641 uint8_t keycode = *(++str);
642 unregister_code(keycode);
644 send_char(ascii_code);
648 { uint8_t ms = interval; while (ms--) wait_ms(1); }
652 void send_string_with_delay_P(const char *str, uint8_t interval) {
654 char ascii_code = pgm_read_byte(str);
655 if (!ascii_code) break;
656 if (ascii_code == 1) {
658 uint8_t keycode = pgm_read_byte(++str);
659 register_code(keycode);
660 unregister_code(keycode);
661 } else if (ascii_code == 2) {
663 uint8_t keycode = pgm_read_byte(++str);
664 register_code(keycode);
665 } else if (ascii_code == 3) {
667 uint8_t keycode = pgm_read_byte(++str);
668 unregister_code(keycode);
670 send_char(ascii_code);
674 { uint8_t ms = interval; while (ms--) wait_ms(1); }
678 void send_char(char ascii_code) {
680 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
681 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
682 register_code(KC_LSFT);
683 register_code(keycode);
684 unregister_code(keycode);
685 unregister_code(KC_LSFT);
687 register_code(keycode);
688 unregister_code(keycode);
692 void set_single_persistent_default_layer(uint8_t default_layer) {
693 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
694 PLAY_SONG(default_layer_songs[default_layer]);
696 eeconfig_update_default_layer(1U<<default_layer);
697 default_layer_set(1U<<default_layer);
700 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
701 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
708 void tap_random_base64(void) {
709 #if defined(__AVR_ATmega32U4__)
710 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
712 uint8_t key = rand() % 64;
716 register_code(KC_LSFT);
717 register_code(key + KC_A);
718 unregister_code(key + KC_A);
719 unregister_code(KC_LSFT);
722 register_code(key - 26 + KC_A);
723 unregister_code(key - 26 + KC_A);
727 unregister_code(KC_0);
730 register_code(key - 53 + KC_1);
731 unregister_code(key - 53 + KC_1);
734 register_code(KC_LSFT);
735 register_code(KC_EQL);
736 unregister_code(KC_EQL);
737 unregister_code(KC_LSFT);
740 register_code(KC_SLSH);
741 unregister_code(KC_SLSH);
746 void matrix_init_quantum() {
747 #ifdef BACKLIGHT_ENABLE
748 backlight_init_ports();
756 void matrix_scan_quantum() {
761 #ifdef TAP_DANCE_ENABLE
762 matrix_scan_tap_dance();
769 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
776 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
778 static const uint8_t backlight_pin = BACKLIGHT_PIN;
780 #if BACKLIGHT_PIN == B7
781 # define COM1x1 COM1C1
783 #elif BACKLIGHT_PIN == B6
784 # define COM1x1 COM1B1
786 #elif BACKLIGHT_PIN == B5
787 # define COM1x1 COM1A1
790 # define NO_BACKLIGHT_CLOCK
793 #ifndef BACKLIGHT_ON_STATE
794 #define BACKLIGHT_ON_STATE 0
797 __attribute__ ((weak))
798 void backlight_init_ports(void)
801 // Setup backlight pin as output and output to on state.
803 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
804 #if BACKLIGHT_ON_STATE == 0
806 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
809 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
812 #ifndef NO_BACKLIGHT_CLOCK
813 // Use full 16-bit resolution.
816 // I could write a wall of text here to explain... but TL;DW
817 // Go read the ATmega32u4 datasheet.
818 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
820 // Pin PB7 = OCR1C (Timer 1, Channel C)
821 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
822 // (i.e. start high, go low when counter matches.)
823 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
824 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
826 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
827 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
831 #ifdef BACKLIGHT_BREATHING
832 breathing_defaults();
836 __attribute__ ((weak))
837 void backlight_set(uint8_t level)
839 // Prevent backlight blink on lowest level
840 // #if BACKLIGHT_ON_STATE == 0
842 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
845 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
849 #ifndef NO_BACKLIGHT_CLOCK
850 // Turn off PWM control on backlight pin, revert to output low.
851 TCCR1A &= ~(_BV(COM1x1));
854 // #if BACKLIGHT_ON_STATE == 0
856 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
859 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
863 #ifndef NO_BACKLIGHT_CLOCK
864 else if ( level == BACKLIGHT_LEVELS ) {
865 // Turn on PWM control of backlight pin
866 TCCR1A |= _BV(COM1x1);
867 // Set the brightness
871 // Turn on PWM control of backlight pin
872 TCCR1A |= _BV(COM1x1);
873 // Set the brightness
874 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
878 #ifdef BACKLIGHT_BREATHING
879 breathing_intensity_default();
883 uint8_t backlight_tick = 0;
885 void backlight_task(void) {
886 #ifdef NO_BACKLIGHT_CLOCK
887 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
888 #if BACKLIGHT_ON_STATE == 0
890 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
893 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
896 #if BACKLIGHT_ON_STATE == 0
898 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
901 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
904 backlight_tick = (backlight_tick + 1) % 16;
908 #ifdef BACKLIGHT_BREATHING
910 #define BREATHING_NO_HALT 0
911 #define BREATHING_HALT_OFF 1
912 #define BREATHING_HALT_ON 2
914 static uint8_t breath_intensity;
915 static uint8_t breath_speed;
916 static uint16_t breathing_index;
917 static uint8_t breathing_halt;
919 void breathing_enable(void)
921 if (get_backlight_level() == 0)
927 // Set breathing_index to be at the midpoint (brightest point)
928 breathing_index = 0x20 << breath_speed;
931 breathing_halt = BREATHING_NO_HALT;
933 // Enable breathing interrupt
934 TIMSK1 |= _BV(OCIE1A);
937 void breathing_pulse(void)
939 if (get_backlight_level() == 0)
945 // Set breathing_index to be at the midpoint + 1 (brightest point)
946 breathing_index = 0x21 << breath_speed;
949 breathing_halt = BREATHING_HALT_ON;
951 // Enable breathing interrupt
952 TIMSK1 |= _BV(OCIE1A);
955 void breathing_disable(void)
957 // Disable breathing interrupt
958 TIMSK1 &= ~_BV(OCIE1A);
959 backlight_set(get_backlight_level());
962 void breathing_self_disable(void)
964 if (get_backlight_level() == 0)
966 breathing_halt = BREATHING_HALT_OFF;
970 breathing_halt = BREATHING_HALT_ON;
973 //backlight_set(get_backlight_level());
976 void breathing_toggle(void)
980 if (get_backlight_level() == 0)
986 // Set breathing_index to be at the midpoint + 1 (brightest point)
987 breathing_index = 0x21 << breath_speed;
990 breathing_halt = BREATHING_NO_HALT;
993 // Toggle breathing interrupt
994 TIMSK1 ^= _BV(OCIE1A);
996 // Restore backlight level
999 backlight_set(get_backlight_level());
1003 bool is_breathing(void)
1005 return (TIMSK1 && _BV(OCIE1A));
1008 void breathing_intensity_default(void)
1010 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
1011 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
1014 void breathing_intensity_set(uint8_t value)
1016 breath_intensity = value;
1019 void breathing_speed_default(void)
1024 void breathing_speed_set(uint8_t value)
1026 bool is_breathing_now = is_breathing();
1027 uint8_t old_breath_speed = breath_speed;
1029 if (is_breathing_now)
1031 // Disable breathing interrupt
1032 TIMSK1 &= ~_BV(OCIE1A);
1035 breath_speed = value;
1037 if (is_breathing_now)
1039 // Adjust index to account for new speed
1040 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
1042 // Enable breathing interrupt
1043 TIMSK1 |= _BV(OCIE1A);
1048 void breathing_speed_inc(uint8_t value)
1050 if ((uint16_t)(breath_speed - value) > 10 )
1052 breathing_speed_set(0);
1056 breathing_speed_set(breath_speed - value);
1060 void breathing_speed_dec(uint8_t value)
1062 if ((uint16_t)(breath_speed + value) > 10 )
1064 breathing_speed_set(10);
1068 breathing_speed_set(breath_speed + value);
1072 void breathing_defaults(void)
1074 breathing_intensity_default();
1075 breathing_speed_default();
1076 breathing_halt = BREATHING_NO_HALT;
1079 /* Breathing Sleep LED brighness(PWM On period) table
1080 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
1082 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
1083 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
1085 static const uint8_t breathing_table[64] PROGMEM = {
1086 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
1087 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
1088 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
1089 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1092 ISR(TIMER1_COMPA_vect)
1094 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
1097 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
1099 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
1101 // Disable breathing interrupt
1102 TIMSK1 &= ~_BV(OCIE1A);
1105 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
1113 __attribute__ ((weak))
1114 void backlight_init_ports(void)
1119 __attribute__ ((weak))
1120 void backlight_set(uint8_t level)
1128 // Functions for spitting out values
1131 void send_dword(uint32_t number) { // this might not actually work
1132 uint16_t word = (number >> 16);
1134 send_word(number & 0xFFFFUL);
1137 void send_word(uint16_t number) {
1138 uint8_t byte = number >> 8;
1140 send_byte(number & 0xFF);
1143 void send_byte(uint8_t number) {
1144 uint8_t nibble = number >> 4;
1145 send_nibble(nibble);
1146 send_nibble(number & 0xF);
1149 void send_nibble(uint8_t number) {
1152 register_code(KC_0);
1153 unregister_code(KC_0);
1156 register_code(KC_1 + (number - 1));
1157 unregister_code(KC_1 + (number - 1));
1160 register_code(KC_A + (number - 0xA));
1161 unregister_code(KC_A + (number - 0xA));
1167 __attribute__((weak))
1168 uint16_t hex_to_keycode(uint8_t hex)
1173 } else if (hex < 0xA) {
1174 return KC_1 + (hex - 0x1);
1176 return KC_A + (hex - 0xA);
1180 void api_send_unicode(uint32_t unicode) {
1183 dword_to_bytes(unicode, chunk);
1184 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1188 __attribute__ ((weak))
1189 void led_set_user(uint8_t usb_led) {
1193 __attribute__ ((weak))
1194 void led_set_kb(uint8_t usb_led) {
1195 led_set_user(usb_led);
1198 __attribute__ ((weak))
1199 void led_init_ports(void)
1204 __attribute__ ((weak))
1205 void led_set(uint8_t usb_led)
1210 // // Using PE6 Caps Lock LED
1211 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1221 // PORTE &= ~(1<<6);
1224 led_set_kb(usb_led);
1228 //------------------------------------------------------------------------------
1229 // Override these functions in your keymap file to play different tunes on
1230 // different events such as startup and bootloader jump
1232 __attribute__ ((weak))
1233 void startup_user() {}
1235 __attribute__ ((weak))
1236 void shutdown_user() {}
1238 //------------------------------------------------------------------------------