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 #ifdef CATERINA_BOOTLOADER
147 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
152 // Shift / paren setup
155 #define LSPO_KEY KC_9
158 #define RSPC_KEY KC_0
161 static bool shift_interrupted[2] = {0, 0};
162 static uint16_t scs_timer[2] = {0, 0};
164 bool process_record_quantum(keyrecord_t *record) {
166 /* This gets the keycode from the key pressed */
167 keypos_t key = record->event.key;
170 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
171 /* TODO: Use store_or_get_action() or a similar function. */
172 if (!disable_action_cache) {
175 if (record->event.pressed) {
176 layer = layer_switch_get_layer(key);
177 update_source_layers_cache(key, layer);
179 layer = read_source_layers_cache(key);
181 keycode = keymap_key_to_keycode(layer, key);
184 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
186 // This is how you use actions here
187 // if (keycode == KC_LEAD) {
189 // action.code = ACTION_DEFAULT_LAYER_SET(0);
190 // process_action(record, action);
195 #if defined(KEY_LOCK_ENABLE)
196 // Must run first to be able to mask key_up events.
197 process_key_lock(&keycode, record) &&
199 process_record_kb(keycode, record) &&
200 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
201 process_midi(keycode, record) &&
204 process_audio(keycode, record) &&
207 process_steno(keycode, record) &&
209 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
210 process_music(keycode, record) &&
212 #ifdef TAP_DANCE_ENABLE
213 process_tap_dance(keycode, record) &&
215 #ifndef DISABLE_LEADER
216 process_leader(keycode, record) &&
218 #ifndef DISABLE_CHORDING
219 process_chording(keycode, record) &&
222 process_combo(keycode, record) &&
224 #ifdef UNICODE_ENABLE
225 process_unicode(keycode, record) &&
228 process_ucis(keycode, record) &&
230 #ifdef PRINTING_ENABLE
231 process_printer(keycode, record) &&
233 #ifdef UNICODEMAP_ENABLE
234 process_unicode_map(keycode, record) &&
240 // Shift / paren setup
244 if (record->event.pressed) {
250 if (record->event.pressed) {
251 print("\nDEBUG: enabled.\n");
256 #ifdef FAUXCLICKY_ENABLE
258 if (record->event.pressed) {
264 if (record->event.pressed) {
270 if (record->event.pressed) {
276 #ifdef RGBLIGHT_ENABLE
278 if (record->event.pressed) {
284 if (record->event.pressed) {
290 if (record->event.pressed) {
291 rgblight_increase_hue();
296 if (record->event.pressed) {
297 rgblight_decrease_hue();
302 if (record->event.pressed) {
303 rgblight_increase_sat();
308 if (record->event.pressed) {
309 rgblight_decrease_sat();
314 if (record->event.pressed) {
315 rgblight_increase_val();
320 if (record->event.pressed) {
321 rgblight_decrease_val();
328 if (record->event.pressed) {
329 set_output(OUTPUT_AUTO);
334 if (record->event.pressed) {
335 set_output(OUTPUT_USB);
339 #ifdef BLUETOOTH_ENABLE
341 if (record->event.pressed) {
342 set_output(OUTPUT_BLUETOOTH);
348 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
349 if (record->event.pressed) {
350 // MAGIC actions (BOOTMAGIC without the boot)
351 if (!eeconfig_is_enabled()) {
355 keymap_config.raw = eeconfig_read_keymap();
358 case MAGIC_SWAP_CONTROL_CAPSLOCK:
359 keymap_config.swap_control_capslock = true;
361 case MAGIC_CAPSLOCK_TO_CONTROL:
362 keymap_config.capslock_to_control = true;
364 case MAGIC_SWAP_LALT_LGUI:
365 keymap_config.swap_lalt_lgui = true;
367 case MAGIC_SWAP_RALT_RGUI:
368 keymap_config.swap_ralt_rgui = true;
371 keymap_config.no_gui = true;
373 case MAGIC_SWAP_GRAVE_ESC:
374 keymap_config.swap_grave_esc = true;
376 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
377 keymap_config.swap_backslash_backspace = true;
379 case MAGIC_HOST_NKRO:
380 keymap_config.nkro = true;
382 case MAGIC_SWAP_ALT_GUI:
383 keymap_config.swap_lalt_lgui = true;
384 keymap_config.swap_ralt_rgui = true;
386 PLAY_SONG(ag_swap_song);
389 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
390 keymap_config.swap_control_capslock = false;
392 case MAGIC_UNCAPSLOCK_TO_CONTROL:
393 keymap_config.capslock_to_control = false;
395 case MAGIC_UNSWAP_LALT_LGUI:
396 keymap_config.swap_lalt_lgui = false;
398 case MAGIC_UNSWAP_RALT_RGUI:
399 keymap_config.swap_ralt_rgui = false;
402 keymap_config.no_gui = false;
404 case MAGIC_UNSWAP_GRAVE_ESC:
405 keymap_config.swap_grave_esc = false;
407 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
408 keymap_config.swap_backslash_backspace = false;
410 case MAGIC_UNHOST_NKRO:
411 keymap_config.nkro = false;
413 case MAGIC_UNSWAP_ALT_GUI:
414 keymap_config.swap_lalt_lgui = false;
415 keymap_config.swap_ralt_rgui = false;
417 PLAY_SONG(ag_norm_song);
420 case MAGIC_TOGGLE_NKRO:
421 keymap_config.nkro = !keymap_config.nkro;
426 eeconfig_update_keymap(keymap_config.raw);
427 clear_keyboard(); // clear to prevent stuck keys
433 if (record->event.pressed) {
434 shift_interrupted[0] = false;
435 scs_timer[0] = timer_read ();
436 register_mods(MOD_BIT(KC_LSFT));
439 #ifdef DISABLE_SPACE_CADET_ROLLOVER
440 if (get_mods() & MOD_BIT(KC_RSFT)) {
441 shift_interrupted[0] = true;
442 shift_interrupted[1] = true;
445 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
446 register_code(LSPO_KEY);
447 unregister_code(LSPO_KEY);
449 unregister_mods(MOD_BIT(KC_LSFT));
456 if (record->event.pressed) {
457 shift_interrupted[1] = false;
458 scs_timer[1] = timer_read ();
459 register_mods(MOD_BIT(KC_RSFT));
462 #ifdef DISABLE_SPACE_CADET_ROLLOVER
463 if (get_mods() & MOD_BIT(KC_LSFT)) {
464 shift_interrupted[0] = true;
465 shift_interrupted[1] = true;
468 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
469 register_code(RSPC_KEY);
470 unregister_code(RSPC_KEY);
472 unregister_mods(MOD_BIT(KC_RSFT));
478 void (*method)(uint8_t) = (record->event.pressed) ? &add_key : &del_key;
479 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
480 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
482 #ifdef GRAVE_ESC_CTRL_OVERRIDE
483 // if CTRL is pressed, ESC is always read as ESC, even if SHIFT or GUI is pressed.
484 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
485 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL)))
489 method(shifted ? KC_GRAVE : KC_ESCAPE);
490 send_keyboard_report();
493 shift_interrupted[0] = true;
494 shift_interrupted[1] = true;
499 return process_action_kb(record);
502 __attribute__ ((weak))
503 const bool ascii_to_shift_lut[0x80] PROGMEM = {
504 0, 0, 0, 0, 0, 0, 0, 0,
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, 1, 1, 1, 1, 1, 1, 0,
509 1, 1, 1, 1, 0, 0, 0, 0,
510 0, 0, 0, 0, 0, 0, 0, 0,
511 0, 0, 1, 0, 1, 0, 1, 1,
512 1, 1, 1, 1, 1, 1, 1, 1,
513 1, 1, 1, 1, 1, 1, 1, 1,
514 1, 1, 1, 1, 1, 1, 1, 1,
515 1, 1, 1, 0, 0, 0, 1, 1,
516 0, 0, 0, 0, 0, 0, 0, 0,
517 0, 0, 0, 0, 0, 0, 0, 0,
518 0, 0, 0, 0, 0, 0, 0, 0,
519 0, 0, 0, 1, 1, 1, 1, 0
522 __attribute__ ((weak))
523 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
524 0, 0, 0, 0, 0, 0, 0, 0,
525 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
526 0, 0, 0, 0, 0, 0, 0, 0,
527 0, 0, 0, KC_ESC, 0, 0, 0, 0,
528 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
529 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
530 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
531 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
532 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
533 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
534 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
535 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
536 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
537 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
538 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
539 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
542 void send_string(const char *str) {
543 send_string_with_delay(str, 0);
546 void send_string_with_delay(const char *str, uint8_t interval) {
549 uint8_t ascii_code = pgm_read_byte(str);
550 if (!ascii_code) break;
551 keycode = pgm_read_byte(&ascii_to_keycode_lut[ascii_code]);
552 if (pgm_read_byte(&ascii_to_shift_lut[ascii_code])) {
553 register_code(KC_LSFT);
554 register_code(keycode);
555 unregister_code(keycode);
556 unregister_code(KC_LSFT);
559 register_code(keycode);
560 unregister_code(keycode);
564 { uint8_t ms = interval; while (ms--) wait_ms(1); }
568 void set_single_persistent_default_layer(uint8_t default_layer) {
569 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
570 PLAY_SONG(default_layer_songs[default_layer]);
572 eeconfig_update_default_layer(1U<<default_layer);
573 default_layer_set(1U<<default_layer);
576 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
577 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
584 void tap_random_base64(void) {
585 #if defined(__AVR_ATmega32U4__)
586 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
588 uint8_t key = rand() % 64;
592 register_code(KC_LSFT);
593 register_code(key + KC_A);
594 unregister_code(key + KC_A);
595 unregister_code(KC_LSFT);
598 register_code(key - 26 + KC_A);
599 unregister_code(key - 26 + KC_A);
603 unregister_code(KC_0);
606 register_code(key - 53 + KC_1);
607 unregister_code(key - 53 + KC_1);
610 register_code(KC_LSFT);
611 register_code(KC_EQL);
612 unregister_code(KC_EQL);
613 unregister_code(KC_LSFT);
616 register_code(KC_SLSH);
617 unregister_code(KC_SLSH);
622 void matrix_init_quantum() {
623 #ifdef BACKLIGHT_ENABLE
624 backlight_init_ports();
632 void matrix_scan_quantum() {
637 #ifdef TAP_DANCE_ENABLE
638 matrix_scan_tap_dance();
645 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
652 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
654 static const uint8_t backlight_pin = BACKLIGHT_PIN;
656 #if BACKLIGHT_PIN == B7
657 # define COM1x1 COM1C1
659 #elif BACKLIGHT_PIN == B6
660 # define COM1x1 COM1B1
662 #elif BACKLIGHT_PIN == B5
663 # define COM1x1 COM1A1
666 # define NO_BACKLIGHT_CLOCK
669 #ifndef BACKLIGHT_ON_STATE
670 #define BACKLIGHT_ON_STATE 0
673 __attribute__ ((weak))
674 void backlight_init_ports(void)
677 // Setup backlight pin as output and output to on state.
679 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
680 #if BACKLIGHT_ON_STATE == 0
682 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
685 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
688 #ifndef NO_BACKLIGHT_CLOCK
689 // Use full 16-bit resolution.
692 // I could write a wall of text here to explain... but TL;DW
693 // Go read the ATmega32u4 datasheet.
694 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
696 // Pin PB7 = OCR1C (Timer 1, Channel C)
697 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
698 // (i.e. start high, go low when counter matches.)
699 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
700 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
702 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
703 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
707 #ifdef BACKLIGHT_BREATHING
708 breathing_defaults();
712 __attribute__ ((weak))
713 void backlight_set(uint8_t level)
715 // Prevent backlight blink on lowest level
716 // #if BACKLIGHT_ON_STATE == 0
718 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
721 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
725 #ifndef NO_BACKLIGHT_CLOCK
726 // Turn off PWM control on backlight pin, revert to output low.
727 TCCR1A &= ~(_BV(COM1x1));
730 // #if BACKLIGHT_ON_STATE == 0
732 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
735 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
739 #ifndef NO_BACKLIGHT_CLOCK
740 else if ( level == BACKLIGHT_LEVELS ) {
741 // Turn on PWM control of backlight pin
742 TCCR1A |= _BV(COM1x1);
743 // Set the brightness
747 // Turn on PWM control of backlight pin
748 TCCR1A |= _BV(COM1x1);
749 // Set the brightness
750 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
754 #ifdef BACKLIGHT_BREATHING
755 breathing_intensity_default();
759 uint8_t backlight_tick = 0;
761 void backlight_task(void) {
762 #ifdef NO_BACKLIGHT_CLOCK
763 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
764 #if BACKLIGHT_ON_STATE == 0
766 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
769 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
772 #if BACKLIGHT_ON_STATE == 0
774 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
777 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
780 backlight_tick = (backlight_tick + 1) % 16;
784 #ifdef BACKLIGHT_BREATHING
786 #define BREATHING_NO_HALT 0
787 #define BREATHING_HALT_OFF 1
788 #define BREATHING_HALT_ON 2
790 static uint8_t breath_intensity;
791 static uint8_t breath_speed;
792 static uint16_t breathing_index;
793 static uint8_t breathing_halt;
795 void breathing_enable(void)
797 if (get_backlight_level() == 0)
803 // Set breathing_index to be at the midpoint (brightest point)
804 breathing_index = 0x20 << breath_speed;
807 breathing_halt = BREATHING_NO_HALT;
809 // Enable breathing interrupt
810 TIMSK1 |= _BV(OCIE1A);
813 void breathing_pulse(void)
815 if (get_backlight_level() == 0)
821 // Set breathing_index to be at the midpoint + 1 (brightest point)
822 breathing_index = 0x21 << breath_speed;
825 breathing_halt = BREATHING_HALT_ON;
827 // Enable breathing interrupt
828 TIMSK1 |= _BV(OCIE1A);
831 void breathing_disable(void)
833 // Disable breathing interrupt
834 TIMSK1 &= ~_BV(OCIE1A);
835 backlight_set(get_backlight_level());
838 void breathing_self_disable(void)
840 if (get_backlight_level() == 0)
842 breathing_halt = BREATHING_HALT_OFF;
846 breathing_halt = BREATHING_HALT_ON;
849 //backlight_set(get_backlight_level());
852 void breathing_toggle(void)
856 if (get_backlight_level() == 0)
862 // Set breathing_index to be at the midpoint + 1 (brightest point)
863 breathing_index = 0x21 << breath_speed;
866 breathing_halt = BREATHING_NO_HALT;
869 // Toggle breathing interrupt
870 TIMSK1 ^= _BV(OCIE1A);
872 // Restore backlight level
875 backlight_set(get_backlight_level());
879 bool is_breathing(void)
881 return (TIMSK1 && _BV(OCIE1A));
884 void breathing_intensity_default(void)
886 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
887 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
890 void breathing_intensity_set(uint8_t value)
892 breath_intensity = value;
895 void breathing_speed_default(void)
900 void breathing_speed_set(uint8_t value)
902 bool is_breathing_now = is_breathing();
903 uint8_t old_breath_speed = breath_speed;
905 if (is_breathing_now)
907 // Disable breathing interrupt
908 TIMSK1 &= ~_BV(OCIE1A);
911 breath_speed = value;
913 if (is_breathing_now)
915 // Adjust index to account for new speed
916 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
918 // Enable breathing interrupt
919 TIMSK1 |= _BV(OCIE1A);
924 void breathing_speed_inc(uint8_t value)
926 if ((uint16_t)(breath_speed - value) > 10 )
928 breathing_speed_set(0);
932 breathing_speed_set(breath_speed - value);
936 void breathing_speed_dec(uint8_t value)
938 if ((uint16_t)(breath_speed + value) > 10 )
940 breathing_speed_set(10);
944 breathing_speed_set(breath_speed + value);
948 void breathing_defaults(void)
950 breathing_intensity_default();
951 breathing_speed_default();
952 breathing_halt = BREATHING_NO_HALT;
955 /* Breathing Sleep LED brighness(PWM On period) table
956 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
958 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
959 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
961 static const uint8_t breathing_table[64] PROGMEM = {
962 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
963 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
964 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
965 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
968 ISR(TIMER1_COMPA_vect)
970 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
973 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
975 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
977 // Disable breathing interrupt
978 TIMSK1 &= ~_BV(OCIE1A);
981 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
991 __attribute__ ((weak))
992 void backlight_init_ports(void)
997 __attribute__ ((weak))
998 void backlight_set(uint8_t level)
1006 // Functions for spitting out values
1009 void send_dword(uint32_t number) { // this might not actually work
1010 uint16_t word = (number >> 16);
1012 send_word(number & 0xFFFFUL);
1015 void send_word(uint16_t number) {
1016 uint8_t byte = number >> 8;
1018 send_byte(number & 0xFF);
1021 void send_byte(uint8_t number) {
1022 uint8_t nibble = number >> 4;
1023 send_nibble(nibble);
1024 send_nibble(number & 0xF);
1027 void send_nibble(uint8_t number) {
1030 register_code(KC_0);
1031 unregister_code(KC_0);
1034 register_code(KC_1 + (number - 1));
1035 unregister_code(KC_1 + (number - 1));
1038 register_code(KC_A + (number - 0xA));
1039 unregister_code(KC_A + (number - 0xA));
1045 __attribute__((weak))
1046 uint16_t hex_to_keycode(uint8_t hex)
1050 } else if (hex < 0xA) {
1051 return KC_1 + (hex - 0x1);
1053 return KC_A + (hex - 0xA);
1057 void api_send_unicode(uint32_t unicode) {
1060 dword_to_bytes(unicode, chunk);
1061 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1065 __attribute__ ((weak))
1066 void led_set_user(uint8_t usb_led) {
1070 __attribute__ ((weak))
1071 void led_set_kb(uint8_t usb_led) {
1072 led_set_user(usb_led);
1075 __attribute__ ((weak))
1076 void led_init_ports(void)
1081 __attribute__ ((weak))
1082 void led_set(uint8_t usb_led)
1087 // // Using PE6 Caps Lock LED
1088 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1098 // PORTE &= ~(1<<6);
1101 led_set_kb(usb_led);
1105 //------------------------------------------------------------------------------
1106 // Override these functions in your keymap file to play different tunes on
1107 // different events such as startup and bootloader jump
1109 __attribute__ ((weak))
1110 void startup_user() {}
1112 __attribute__ ((weak))
1113 void shutdown_user() {}
1115 //------------------------------------------------------------------------------