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"
33 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
35 case QK_MODS ... QK_MODS_MAX:
50 if (code < QK_RMODS_MIN) return;
62 static inline void qk_register_weak_mods(uint8_t kc) {
63 add_weak_mods(MOD_BIT(kc));
64 send_keyboard_report();
67 static inline void qk_unregister_weak_mods(uint8_t kc) {
68 del_weak_mods(MOD_BIT(kc));
69 send_keyboard_report();
72 static inline void qk_register_mods(uint8_t kc) {
73 add_weak_mods(MOD_BIT(kc));
74 send_keyboard_report();
77 static inline void qk_unregister_mods(uint8_t kc) {
78 del_weak_mods(MOD_BIT(kc));
79 send_keyboard_report();
82 void register_code16 (uint16_t code) {
83 if (IS_MOD(code) || code == KC_NO) {
84 do_code16 (code, qk_register_mods);
86 do_code16 (code, qk_register_weak_mods);
91 void unregister_code16 (uint16_t code) {
92 unregister_code (code);
93 if (IS_MOD(code) || code == KC_NO) {
94 do_code16 (code, qk_unregister_mods);
96 do_code16 (code, qk_unregister_weak_mods);
100 __attribute__ ((weak))
101 bool process_action_kb(keyrecord_t *record) {
105 __attribute__ ((weak))
106 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
107 return process_record_user(keycode, record);
110 __attribute__ ((weak))
111 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
115 void reset_keyboard(void) {
117 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
118 music_all_notes_off();
122 #ifdef CATERINA_BOOTLOADER
123 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
128 // Shift / paren setup
131 #define LSPO_KEY KC_9
134 #define RSPC_KEY KC_0
137 static bool shift_interrupted[2] = {0, 0};
138 static uint16_t scs_timer[2] = {0, 0};
140 bool process_record_quantum(keyrecord_t *record) {
142 /* This gets the keycode from the key pressed */
143 keypos_t key = record->event.key;
146 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
147 /* TODO: Use store_or_get_action() or a similar function. */
148 if (!disable_action_cache) {
151 if (record->event.pressed) {
152 layer = layer_switch_get_layer(key);
153 update_source_layers_cache(key, layer);
155 layer = read_source_layers_cache(key);
157 keycode = keymap_key_to_keycode(layer, key);
160 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
162 // This is how you use actions here
163 // if (keycode == KC_LEAD) {
165 // action.code = ACTION_DEFAULT_LAYER_SET(0);
166 // process_action(record, action);
171 process_record_kb(keycode, record) &&
172 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
173 process_midi(keycode, record) &&
176 process_audio(keycode, record) &&
178 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
179 process_music(keycode, record) &&
181 #ifdef TAP_DANCE_ENABLE
182 process_tap_dance(keycode, record) &&
184 #ifndef DISABLE_LEADER
185 process_leader(keycode, record) &&
187 #ifndef DISABLE_CHORDING
188 process_chording(keycode, record) &&
191 process_combo(keycode, record) &&
193 #ifdef UNICODE_ENABLE
194 process_unicode(keycode, record) &&
197 process_ucis(keycode, record) &&
199 #ifdef PRINTING_ENABLE
200 process_printer(keycode, record) &&
202 #ifdef UNICODEMAP_ENABLE
203 process_unicode_map(keycode, record) &&
209 // Shift / paren setup
213 if (record->event.pressed) {
219 if (record->event.pressed) {
220 print("\nDEBUG: enabled.\n");
225 #ifdef FAUXCLICKY_ENABLE
227 if (record->event.pressed) {
233 if (record->event.pressed) {
239 if (record->event.pressed) {
245 #ifdef RGBLIGHT_ENABLE
247 if (record->event.pressed) {
253 if (record->event.pressed) {
259 if (record->event.pressed) {
260 rgblight_increase_hue();
265 if (record->event.pressed) {
266 rgblight_decrease_hue();
271 if (record->event.pressed) {
272 rgblight_increase_sat();
277 if (record->event.pressed) {
278 rgblight_decrease_sat();
283 if (record->event.pressed) {
284 rgblight_increase_val();
289 if (record->event.pressed) {
290 rgblight_decrease_val();
297 if (record->event.pressed) {
298 set_output(OUTPUT_AUTO);
303 if (record->event.pressed) {
304 set_output(OUTPUT_USB);
308 #ifdef BLUETOOTH_ENABLE
310 if (record->event.pressed) {
311 set_output(OUTPUT_BLUETOOTH);
317 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
318 if (record->event.pressed) {
319 // MAGIC actions (BOOTMAGIC without the boot)
320 if (!eeconfig_is_enabled()) {
324 keymap_config.raw = eeconfig_read_keymap();
327 case MAGIC_SWAP_CONTROL_CAPSLOCK:
328 keymap_config.swap_control_capslock = true;
330 case MAGIC_CAPSLOCK_TO_CONTROL:
331 keymap_config.capslock_to_control = true;
333 case MAGIC_SWAP_LALT_LGUI:
334 keymap_config.swap_lalt_lgui = true;
336 case MAGIC_SWAP_RALT_RGUI:
337 keymap_config.swap_ralt_rgui = true;
340 keymap_config.no_gui = true;
342 case MAGIC_SWAP_GRAVE_ESC:
343 keymap_config.swap_grave_esc = true;
345 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
346 keymap_config.swap_backslash_backspace = true;
348 case MAGIC_HOST_NKRO:
349 keymap_config.nkro = true;
351 case MAGIC_SWAP_ALT_GUI:
352 keymap_config.swap_lalt_lgui = true;
353 keymap_config.swap_ralt_rgui = true;
355 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
356 keymap_config.swap_control_capslock = false;
358 case MAGIC_UNCAPSLOCK_TO_CONTROL:
359 keymap_config.capslock_to_control = false;
361 case MAGIC_UNSWAP_LALT_LGUI:
362 keymap_config.swap_lalt_lgui = false;
364 case MAGIC_UNSWAP_RALT_RGUI:
365 keymap_config.swap_ralt_rgui = false;
368 keymap_config.no_gui = false;
370 case MAGIC_UNSWAP_GRAVE_ESC:
371 keymap_config.swap_grave_esc = false;
373 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
374 keymap_config.swap_backslash_backspace = false;
376 case MAGIC_UNHOST_NKRO:
377 keymap_config.nkro = false;
379 case MAGIC_UNSWAP_ALT_GUI:
380 keymap_config.swap_lalt_lgui = false;
381 keymap_config.swap_ralt_rgui = false;
383 case MAGIC_TOGGLE_NKRO:
384 keymap_config.nkro = !keymap_config.nkro;
389 eeconfig_update_keymap(keymap_config.raw);
390 clear_keyboard(); // clear to prevent stuck keys
396 if (record->event.pressed) {
397 shift_interrupted[0] = false;
398 scs_timer[0] = timer_read ();
399 register_mods(MOD_BIT(KC_LSFT));
402 #ifdef DISABLE_SPACE_CADET_ROLLOVER
403 if (get_mods() & MOD_BIT(KC_RSFT)) {
404 shift_interrupted[0] = true;
405 shift_interrupted[1] = true;
408 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
409 register_code(LSPO_KEY);
410 unregister_code(LSPO_KEY);
412 unregister_mods(MOD_BIT(KC_LSFT));
419 if (record->event.pressed) {
420 shift_interrupted[1] = false;
421 scs_timer[1] = timer_read ();
422 register_mods(MOD_BIT(KC_RSFT));
425 #ifdef DISABLE_SPACE_CADET_ROLLOVER
426 if (get_mods() & MOD_BIT(KC_LSFT)) {
427 shift_interrupted[0] = true;
428 shift_interrupted[1] = true;
431 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
432 register_code(RSPC_KEY);
433 unregister_code(RSPC_KEY);
435 unregister_mods(MOD_BIT(KC_RSFT));
441 shift_interrupted[0] = true;
442 shift_interrupted[1] = true;
447 return process_action_kb(record);
450 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
451 0, 0, 0, 0, 0, 0, 0, 0,
452 0, 0, 0, 0, 0, 0, 0, 0,
453 0, 0, 0, 0, 0, 0, 0, 0,
454 0, 0, 0, 0, 0, 0, 0, 0,
455 0, 1, 1, 1, 1, 1, 1, 0,
456 1, 1, 1, 1, 0, 0, 0, 0,
457 0, 0, 0, 0, 0, 0, 0, 0,
458 0, 0, 1, 0, 1, 0, 1, 1,
459 1, 1, 1, 1, 1, 1, 1, 1,
460 1, 1, 1, 1, 1, 1, 1, 1,
461 1, 1, 1, 1, 1, 1, 1, 1,
462 1, 1, 1, 0, 0, 0, 1, 1,
463 0, 0, 0, 0, 0, 0, 0, 0,
464 0, 0, 0, 0, 0, 0, 0, 0,
465 0, 0, 0, 0, 0, 0, 0, 0,
466 0, 0, 0, 1, 1, 1, 1, 0
469 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
470 0, 0, 0, 0, 0, 0, 0, 0,
471 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
472 0, 0, 0, 0, 0, 0, 0, 0,
473 0, 0, 0, KC_ESC, 0, 0, 0, 0,
474 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
475 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
476 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
477 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
478 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
479 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
480 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
481 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
482 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
483 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
484 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
485 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
488 /* for users whose OSes are set to Colemak */
490 #include "keymap_colemak.h"
492 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
493 0, 0, 0, 0, 0, 0, 0, 0,
494 0, 0, 0, 0, 0, 0, 0, 0,
495 0, 0, 0, 0, 0, 0, 0, 0,
496 0, 0, 0, 0, 0, 0, 0, 0,
497 0, 1, 1, 1, 1, 1, 1, 0,
498 1, 1, 1, 1, 0, 0, 0, 0,
499 0, 0, 0, 0, 0, 0, 0, 0,
500 0, 0, 1, 0, 1, 0, 1, 1,
501 1, 1, 1, 1, 1, 1, 1, 1,
502 1, 1, 1, 1, 1, 1, 1, 1,
503 1, 1, 1, 1, 1, 1, 1, 1,
504 1, 1, 1, 0, 0, 0, 1, 1,
505 0, 0, 0, 0, 0, 0, 0, 0,
506 0, 0, 0, 0, 0, 0, 0, 0,
507 0, 0, 0, 0, 0, 0, 0, 0,
508 0, 0, 0, 1, 1, 1, 1, 0
511 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
512 0, 0, 0, 0, 0, 0, 0, 0,
513 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
514 0, 0, 0, 0, 0, 0, 0, 0,
515 0, 0, 0, KC_ESC, 0, 0, 0, 0,
516 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
517 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
518 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
519 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
520 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
521 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
522 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
523 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
524 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
525 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
526 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
527 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
532 void send_string(const char *str) {
535 uint8_t ascii_code = pgm_read_byte(str);
536 if (!ascii_code) break;
537 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
538 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
539 register_code(KC_LSFT);
540 register_code(keycode);
541 unregister_code(keycode);
542 unregister_code(KC_LSFT);
545 register_code(keycode);
546 unregister_code(keycode);
552 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
553 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
560 void tap_random_base64(void) {
561 #if defined(__AVR_ATmega32U4__)
562 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
564 uint8_t key = rand() % 64;
568 register_code(KC_LSFT);
569 register_code(key + KC_A);
570 unregister_code(key + KC_A);
571 unregister_code(KC_LSFT);
574 register_code(key - 26 + KC_A);
575 unregister_code(key - 26 + KC_A);
579 unregister_code(KC_0);
582 register_code(key - 53 + KC_1);
583 unregister_code(key - 53 + KC_1);
586 register_code(KC_LSFT);
587 register_code(KC_EQL);
588 unregister_code(KC_EQL);
589 unregister_code(KC_LSFT);
592 register_code(KC_SLSH);
593 unregister_code(KC_SLSH);
598 void matrix_init_quantum() {
599 #ifdef BACKLIGHT_ENABLE
600 backlight_init_ports();
605 void matrix_scan_quantum() {
610 #ifdef TAP_DANCE_ENABLE
611 matrix_scan_tap_dance();
618 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
625 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
627 static const uint8_t backlight_pin = BACKLIGHT_PIN;
629 #if BACKLIGHT_PIN == B7
630 # define COM1x1 COM1C1
632 #elif BACKLIGHT_PIN == B6
633 # define COM1x1 COM1B1
635 #elif BACKLIGHT_PIN == B5
636 # define COM1x1 COM1A1
639 # define NO_BACKLIGHT_CLOCK
642 #ifndef BACKLIGHT_ON_STATE
643 #define BACKLIGHT_ON_STATE 0
646 __attribute__ ((weak))
647 void backlight_init_ports(void)
650 // Setup backlight pin as output and output to on state.
652 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
653 #if BACKLIGHT_ON_STATE == 0
655 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
658 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
661 #ifndef NO_BACKLIGHT_CLOCK
662 // Use full 16-bit resolution.
665 // I could write a wall of text here to explain... but TL;DW
666 // Go read the ATmega32u4 datasheet.
667 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
669 // Pin PB7 = OCR1C (Timer 1, Channel C)
670 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
671 // (i.e. start high, go low when counter matches.)
672 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
673 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
675 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
676 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
680 #ifdef BACKLIGHT_BREATHING
681 breathing_defaults();
685 __attribute__ ((weak))
686 void backlight_set(uint8_t level)
688 // Prevent backlight blink on lowest level
689 // #if BACKLIGHT_ON_STATE == 0
691 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
694 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
698 #ifndef NO_BACKLIGHT_CLOCK
699 // Turn off PWM control on backlight pin, revert to output low.
700 TCCR1A &= ~(_BV(COM1x1));
703 // #if BACKLIGHT_ON_STATE == 0
705 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
708 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
712 #ifndef NO_BACKLIGHT_CLOCK
713 else if ( level == BACKLIGHT_LEVELS ) {
714 // Turn on PWM control of backlight pin
715 TCCR1A |= _BV(COM1x1);
716 // Set the brightness
720 // Turn on PWM control of backlight pin
721 TCCR1A |= _BV(COM1x1);
722 // Set the brightness
723 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
727 #ifdef BACKLIGHT_BREATHING
728 breathing_intensity_default();
732 uint8_t backlight_tick = 0;
734 void backlight_task(void) {
735 #ifdef NO_BACKLIGHT_CLOCK
736 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
737 #if BACKLIGHT_ON_STATE == 0
739 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
742 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
745 #if BACKLIGHT_ON_STATE == 0
747 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
750 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
753 backlight_tick = (backlight_tick + 1) % 16;
757 #ifdef BACKLIGHT_BREATHING
759 #define BREATHING_NO_HALT 0
760 #define BREATHING_HALT_OFF 1
761 #define BREATHING_HALT_ON 2
763 static uint8_t breath_intensity;
764 static uint8_t breath_speed;
765 static uint16_t breathing_index;
766 static uint8_t breathing_halt;
768 void breathing_enable(void)
770 if (get_backlight_level() == 0)
776 // Set breathing_index to be at the midpoint (brightest point)
777 breathing_index = 0x20 << breath_speed;
780 breathing_halt = BREATHING_NO_HALT;
782 // Enable breathing interrupt
783 TIMSK1 |= _BV(OCIE1A);
786 void breathing_pulse(void)
788 if (get_backlight_level() == 0)
794 // Set breathing_index to be at the midpoint + 1 (brightest point)
795 breathing_index = 0x21 << breath_speed;
798 breathing_halt = BREATHING_HALT_ON;
800 // Enable breathing interrupt
801 TIMSK1 |= _BV(OCIE1A);
804 void breathing_disable(void)
806 // Disable breathing interrupt
807 TIMSK1 &= ~_BV(OCIE1A);
808 backlight_set(get_backlight_level());
811 void breathing_self_disable(void)
813 if (get_backlight_level() == 0)
815 breathing_halt = BREATHING_HALT_OFF;
819 breathing_halt = BREATHING_HALT_ON;
822 //backlight_set(get_backlight_level());
825 void breathing_toggle(void)
829 if (get_backlight_level() == 0)
835 // Set breathing_index to be at the midpoint + 1 (brightest point)
836 breathing_index = 0x21 << breath_speed;
839 breathing_halt = BREATHING_NO_HALT;
842 // Toggle breathing interrupt
843 TIMSK1 ^= _BV(OCIE1A);
845 // Restore backlight level
848 backlight_set(get_backlight_level());
852 bool is_breathing(void)
854 return (TIMSK1 && _BV(OCIE1A));
857 void breathing_intensity_default(void)
859 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
860 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
863 void breathing_intensity_set(uint8_t value)
865 breath_intensity = value;
868 void breathing_speed_default(void)
873 void breathing_speed_set(uint8_t value)
875 bool is_breathing_now = is_breathing();
876 uint8_t old_breath_speed = breath_speed;
878 if (is_breathing_now)
880 // Disable breathing interrupt
881 TIMSK1 &= ~_BV(OCIE1A);
884 breath_speed = value;
886 if (is_breathing_now)
888 // Adjust index to account for new speed
889 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
891 // Enable breathing interrupt
892 TIMSK1 |= _BV(OCIE1A);
897 void breathing_speed_inc(uint8_t value)
899 if ((uint16_t)(breath_speed - value) > 10 )
901 breathing_speed_set(0);
905 breathing_speed_set(breath_speed - value);
909 void breathing_speed_dec(uint8_t value)
911 if ((uint16_t)(breath_speed + value) > 10 )
913 breathing_speed_set(10);
917 breathing_speed_set(breath_speed + value);
921 void breathing_defaults(void)
923 breathing_intensity_default();
924 breathing_speed_default();
925 breathing_halt = BREATHING_NO_HALT;
928 /* Breathing Sleep LED brighness(PWM On period) table
929 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
931 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
932 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
934 static const uint8_t breathing_table[64] PROGMEM = {
935 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
936 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
937 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
938 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
941 ISR(TIMER1_COMPA_vect)
943 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
946 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
948 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
950 // Disable breathing interrupt
951 TIMSK1 &= ~_BV(OCIE1A);
954 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
964 __attribute__ ((weak))
965 void backlight_init_ports(void)
970 __attribute__ ((weak))
971 void backlight_set(uint8_t level)
979 // Functions for spitting out values
982 void send_dword(uint32_t number) { // this might not actually work
983 uint16_t word = (number >> 16);
985 send_word(number & 0xFFFFUL);
988 void send_word(uint16_t number) {
989 uint8_t byte = number >> 8;
991 send_byte(number & 0xFF);
994 void send_byte(uint8_t number) {
995 uint8_t nibble = number >> 4;
997 send_nibble(number & 0xF);
1000 void send_nibble(uint8_t number) {
1003 register_code(KC_0);
1004 unregister_code(KC_0);
1007 register_code(KC_1 + (number - 1));
1008 unregister_code(KC_1 + (number - 1));
1011 register_code(KC_A + (number - 0xA));
1012 unregister_code(KC_A + (number - 0xA));
1018 __attribute__((weak))
1019 uint16_t hex_to_keycode(uint8_t hex)
1023 } else if (hex < 0xA) {
1024 return KC_1 + (hex - 0x1);
1026 return KC_A + (hex - 0xA);
1030 void api_send_unicode(uint32_t unicode) {
1033 dword_to_bytes(unicode, chunk);
1034 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1038 __attribute__ ((weak))
1039 void led_set_user(uint8_t usb_led) {
1043 __attribute__ ((weak))
1044 void led_set_kb(uint8_t usb_led) {
1045 led_set_user(usb_led);
1048 __attribute__ ((weak))
1049 void led_init_ports(void)
1054 __attribute__ ((weak))
1055 void led_set(uint8_t usb_led)
1060 // // Using PE6 Caps Lock LED
1061 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1071 // PORTE &= ~(1<<6);
1074 led_set_kb(usb_led);
1078 //------------------------------------------------------------------------------
1079 // Override these functions in your keymap file to play different tunes on
1080 // different events such as startup and bootloader jump
1082 __attribute__ ((weak))
1083 void startup_user() {}
1085 __attribute__ ((weak))
1086 void shutdown_user() {}
1088 //------------------------------------------------------------------------------