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 #ifndef DEFAULT_LAYER_SONGS
44 #define DEFAULT_LAYER_SONGS { }
46 float goodbye_song[][2] = GOODBYE_SONG;
47 float ag_norm_song[][2] = AG_NORM_SONG;
48 float ag_swap_song[][2] = AG_SWAP_SONG;
49 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
52 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
54 case QK_MODS ... QK_MODS_MAX:
69 if (code < QK_RMODS_MIN) return;
81 static inline void qk_register_weak_mods(uint8_t kc) {
82 add_weak_mods(MOD_BIT(kc));
83 send_keyboard_report();
86 static inline void qk_unregister_weak_mods(uint8_t kc) {
87 del_weak_mods(MOD_BIT(kc));
88 send_keyboard_report();
91 static inline void qk_register_mods(uint8_t kc) {
92 add_weak_mods(MOD_BIT(kc));
93 send_keyboard_report();
96 static inline void qk_unregister_mods(uint8_t kc) {
97 del_weak_mods(MOD_BIT(kc));
98 send_keyboard_report();
101 void register_code16 (uint16_t code) {
102 if (IS_MOD(code) || code == KC_NO) {
103 do_code16 (code, qk_register_mods);
105 do_code16 (code, qk_register_weak_mods);
107 register_code (code);
110 void unregister_code16 (uint16_t code) {
111 unregister_code (code);
112 if (IS_MOD(code) || code == KC_NO) {
113 do_code16 (code, qk_unregister_mods);
115 do_code16 (code, qk_unregister_weak_mods);
119 __attribute__ ((weak))
120 bool process_action_kb(keyrecord_t *record) {
124 __attribute__ ((weak))
125 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
126 return process_record_user(keycode, record);
129 __attribute__ ((weak))
130 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
134 void reset_keyboard(void) {
136 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
137 music_all_notes_off();
138 uint16_t timer_start = timer_read();
139 PLAY_SONG(goodbye_song);
141 while(timer_elapsed(timer_start) < 250)
147 #ifdef CATERINA_BOOTLOADER
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 bool process_record_quantum(keyrecord_t *record) {
167 /* This gets the keycode from the key pressed */
168 keypos_t key = record->event.key;
171 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
172 /* TODO: Use store_or_get_action() or a similar function. */
173 if (!disable_action_cache) {
176 if (record->event.pressed) {
177 layer = layer_switch_get_layer(key);
178 update_source_layers_cache(key, layer);
180 layer = read_source_layers_cache(key);
182 keycode = keymap_key_to_keycode(layer, key);
185 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
187 // This is how you use actions here
188 // if (keycode == KC_LEAD) {
190 // action.code = ACTION_DEFAULT_LAYER_SET(0);
191 // process_action(record, action);
196 #if defined(KEY_LOCK_ENABLE)
197 // Must run first to be able to mask key_up events.
198 process_key_lock(keycode, record) &&
200 process_record_kb(keycode, record) &&
201 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
202 process_midi(keycode, record) &&
205 process_audio(keycode, record) &&
208 process_steno(keycode, record) &&
210 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
211 process_music(keycode, record) &&
213 #ifdef TAP_DANCE_ENABLE
214 process_tap_dance(keycode, record) &&
216 #ifndef DISABLE_LEADER
217 process_leader(keycode, record) &&
219 #ifndef DISABLE_CHORDING
220 process_chording(keycode, record) &&
223 process_combo(keycode, record) &&
225 #ifdef UNICODE_ENABLE
226 process_unicode(keycode, record) &&
229 process_ucis(keycode, record) &&
231 #ifdef PRINTING_ENABLE
232 process_printer(keycode, record) &&
234 #ifdef UNICODEMAP_ENABLE
235 process_unicode_map(keycode, record) &&
241 // Shift / paren setup
245 if (record->event.pressed) {
251 if (record->event.pressed) {
252 print("\nDEBUG: enabled.\n");
257 #ifdef FAUXCLICKY_ENABLE
259 if (record->event.pressed) {
265 if (record->event.pressed) {
271 if (record->event.pressed) {
277 #ifdef RGBLIGHT_ENABLE
279 if (record->event.pressed) {
285 if (record->event.pressed) {
291 if (record->event.pressed) {
292 rgblight_increase_hue();
297 if (record->event.pressed) {
298 rgblight_decrease_hue();
303 if (record->event.pressed) {
304 rgblight_increase_sat();
309 if (record->event.pressed) {
310 rgblight_decrease_sat();
315 if (record->event.pressed) {
316 rgblight_increase_val();
321 if (record->event.pressed) {
322 rgblight_decrease_val();
329 if (record->event.pressed) {
330 set_output(OUTPUT_AUTO);
335 if (record->event.pressed) {
336 set_output(OUTPUT_USB);
340 #ifdef BLUETOOTH_ENABLE
342 if (record->event.pressed) {
343 set_output(OUTPUT_BLUETOOTH);
349 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
350 if (record->event.pressed) {
351 // MAGIC actions (BOOTMAGIC without the boot)
352 if (!eeconfig_is_enabled()) {
356 keymap_config.raw = eeconfig_read_keymap();
359 case MAGIC_SWAP_CONTROL_CAPSLOCK:
360 keymap_config.swap_control_capslock = true;
362 case MAGIC_CAPSLOCK_TO_CONTROL:
363 keymap_config.capslock_to_control = true;
365 case MAGIC_SWAP_LALT_LGUI:
366 keymap_config.swap_lalt_lgui = true;
368 case MAGIC_SWAP_RALT_RGUI:
369 keymap_config.swap_ralt_rgui = true;
372 keymap_config.no_gui = true;
374 case MAGIC_SWAP_GRAVE_ESC:
375 keymap_config.swap_grave_esc = true;
377 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
378 keymap_config.swap_backslash_backspace = true;
380 case MAGIC_HOST_NKRO:
381 keymap_config.nkro = true;
383 case MAGIC_SWAP_ALT_GUI:
384 keymap_config.swap_lalt_lgui = true;
385 keymap_config.swap_ralt_rgui = true;
387 PLAY_SONG(ag_swap_song);
390 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
391 keymap_config.swap_control_capslock = false;
393 case MAGIC_UNCAPSLOCK_TO_CONTROL:
394 keymap_config.capslock_to_control = false;
396 case MAGIC_UNSWAP_LALT_LGUI:
397 keymap_config.swap_lalt_lgui = false;
399 case MAGIC_UNSWAP_RALT_RGUI:
400 keymap_config.swap_ralt_rgui = false;
403 keymap_config.no_gui = false;
405 case MAGIC_UNSWAP_GRAVE_ESC:
406 keymap_config.swap_grave_esc = false;
408 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
409 keymap_config.swap_backslash_backspace = false;
411 case MAGIC_UNHOST_NKRO:
412 keymap_config.nkro = false;
414 case MAGIC_UNSWAP_ALT_GUI:
415 keymap_config.swap_lalt_lgui = false;
416 keymap_config.swap_ralt_rgui = false;
418 PLAY_SONG(ag_norm_song);
421 case MAGIC_TOGGLE_NKRO:
422 keymap_config.nkro = !keymap_config.nkro;
427 eeconfig_update_keymap(keymap_config.raw);
428 clear_keyboard(); // clear to prevent stuck keys
434 if (record->event.pressed) {
435 shift_interrupted[0] = false;
436 scs_timer[0] = timer_read ();
437 register_mods(MOD_BIT(KC_LSFT));
440 #ifdef DISABLE_SPACE_CADET_ROLLOVER
441 if (get_mods() & MOD_BIT(KC_RSFT)) {
442 shift_interrupted[0] = true;
443 shift_interrupted[1] = true;
446 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
447 register_code(LSPO_KEY);
448 unregister_code(LSPO_KEY);
450 unregister_mods(MOD_BIT(KC_LSFT));
457 if (record->event.pressed) {
458 shift_interrupted[1] = false;
459 scs_timer[1] = timer_read ();
460 register_mods(MOD_BIT(KC_RSFT));
463 #ifdef DISABLE_SPACE_CADET_ROLLOVER
464 if (get_mods() & MOD_BIT(KC_LSFT)) {
465 shift_interrupted[0] = true;
466 shift_interrupted[1] = true;
469 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
470 register_code(RSPC_KEY);
471 unregister_code(RSPC_KEY);
473 unregister_mods(MOD_BIT(KC_RSFT));
479 void (*method)(uint8_t) = (record->event.pressed) ? &add_key : &del_key;
480 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
481 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
483 method(shifted ? KC_GRAVE : KC_ESCAPE);
484 send_keyboard_report();
487 shift_interrupted[0] = true;
488 shift_interrupted[1] = true;
493 return process_action_kb(record);
496 __attribute__ ((weak))
497 const bool ascii_to_shift_lut[0x80] PROGMEM = {
498 0, 0, 0, 0, 0, 0, 0, 0,
499 0, 0, 0, 0, 0, 0, 0, 0,
500 0, 0, 0, 0, 0, 0, 0, 0,
501 0, 0, 0, 0, 0, 0, 0, 0,
502 0, 1, 1, 1, 1, 1, 1, 0,
503 1, 1, 1, 1, 0, 0, 0, 0,
504 0, 0, 0, 0, 0, 0, 0, 0,
505 0, 0, 1, 0, 1, 0, 1, 1,
506 1, 1, 1, 1, 1, 1, 1, 1,
507 1, 1, 1, 1, 1, 1, 1, 1,
508 1, 1, 1, 1, 1, 1, 1, 1,
509 1, 1, 1, 0, 0, 0, 1, 1,
510 0, 0, 0, 0, 0, 0, 0, 0,
511 0, 0, 0, 0, 0, 0, 0, 0,
512 0, 0, 0, 0, 0, 0, 0, 0,
513 0, 0, 0, 1, 1, 1, 1, 0
516 __attribute__ ((weak))
517 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
518 0, 0, 0, 0, 0, 0, 0, 0,
519 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
520 0, 0, 0, 0, 0, 0, 0, 0,
521 0, 0, 0, KC_ESC, 0, 0, 0, 0,
522 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
523 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
524 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
525 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
526 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
527 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
528 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
529 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
530 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
531 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
532 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
533 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
536 void send_string(const char *str) {
537 send_string_with_delay(str, 0);
540 void send_string_with_delay(const char *str, uint8_t interval) {
543 uint8_t ascii_code = pgm_read_byte(str);
544 if (!ascii_code) break;
545 keycode = pgm_read_byte(&ascii_to_keycode_lut[ascii_code]);
546 if (pgm_read_byte(&ascii_to_shift_lut[ascii_code])) {
547 register_code(KC_LSFT);
548 register_code(keycode);
549 unregister_code(keycode);
550 unregister_code(KC_LSFT);
553 register_code(keycode);
554 unregister_code(keycode);
558 { uint8_t ms = interval; while (ms--) wait_ms(1); }
562 void set_single_persistent_default_layer(uint8_t default_layer) {
564 PLAY_SONG(default_layer_songs[default_layer]);
566 eeconfig_update_default_layer(1U<<default_layer);
567 default_layer_set(1U<<default_layer);
570 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
571 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
578 void tap_random_base64(void) {
579 #if defined(__AVR_ATmega32U4__)
580 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
582 uint8_t key = rand() % 64;
586 register_code(KC_LSFT);
587 register_code(key + KC_A);
588 unregister_code(key + KC_A);
589 unregister_code(KC_LSFT);
592 register_code(key - 26 + KC_A);
593 unregister_code(key - 26 + KC_A);
597 unregister_code(KC_0);
600 register_code(key - 53 + KC_1);
601 unregister_code(key - 53 + KC_1);
604 register_code(KC_LSFT);
605 register_code(KC_EQL);
606 unregister_code(KC_EQL);
607 unregister_code(KC_LSFT);
610 register_code(KC_SLSH);
611 unregister_code(KC_SLSH);
616 void matrix_init_quantum() {
617 #ifdef BACKLIGHT_ENABLE
618 backlight_init_ports();
626 void matrix_scan_quantum() {
631 #ifdef TAP_DANCE_ENABLE
632 matrix_scan_tap_dance();
639 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
646 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
648 static const uint8_t backlight_pin = BACKLIGHT_PIN;
650 #if BACKLIGHT_PIN == B7
651 # define COM1x1 COM1C1
653 #elif BACKLIGHT_PIN == B6
654 # define COM1x1 COM1B1
656 #elif BACKLIGHT_PIN == B5
657 # define COM1x1 COM1A1
660 # define NO_BACKLIGHT_CLOCK
663 #ifndef BACKLIGHT_ON_STATE
664 #define BACKLIGHT_ON_STATE 0
667 __attribute__ ((weak))
668 void backlight_init_ports(void)
671 // Setup backlight pin as output and output to on state.
673 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
674 #if BACKLIGHT_ON_STATE == 0
676 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
679 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
682 #ifndef NO_BACKLIGHT_CLOCK
683 // Use full 16-bit resolution.
686 // I could write a wall of text here to explain... but TL;DW
687 // Go read the ATmega32u4 datasheet.
688 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
690 // Pin PB7 = OCR1C (Timer 1, Channel C)
691 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
692 // (i.e. start high, go low when counter matches.)
693 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
694 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
696 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
697 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
701 #ifdef BACKLIGHT_BREATHING
702 breathing_defaults();
706 __attribute__ ((weak))
707 void backlight_set(uint8_t level)
709 // Prevent backlight blink on lowest level
710 // #if BACKLIGHT_ON_STATE == 0
712 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
715 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
719 #ifndef NO_BACKLIGHT_CLOCK
720 // Turn off PWM control on backlight pin, revert to output low.
721 TCCR1A &= ~(_BV(COM1x1));
724 // #if BACKLIGHT_ON_STATE == 0
726 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
729 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
733 #ifndef NO_BACKLIGHT_CLOCK
734 else if ( level == BACKLIGHT_LEVELS ) {
735 // Turn on PWM control of backlight pin
736 TCCR1A |= _BV(COM1x1);
737 // Set the brightness
741 // Turn on PWM control of backlight pin
742 TCCR1A |= _BV(COM1x1);
743 // Set the brightness
744 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
748 #ifdef BACKLIGHT_BREATHING
749 breathing_intensity_default();
753 uint8_t backlight_tick = 0;
755 void backlight_task(void) {
756 #ifdef NO_BACKLIGHT_CLOCK
757 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
758 #if BACKLIGHT_ON_STATE == 0
760 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
763 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
766 #if BACKLIGHT_ON_STATE == 0
768 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
771 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
774 backlight_tick = (backlight_tick + 1) % 16;
778 #ifdef BACKLIGHT_BREATHING
780 #define BREATHING_NO_HALT 0
781 #define BREATHING_HALT_OFF 1
782 #define BREATHING_HALT_ON 2
784 static uint8_t breath_intensity;
785 static uint8_t breath_speed;
786 static uint16_t breathing_index;
787 static uint8_t breathing_halt;
789 void breathing_enable(void)
791 if (get_backlight_level() == 0)
797 // Set breathing_index to be at the midpoint (brightest point)
798 breathing_index = 0x20 << breath_speed;
801 breathing_halt = BREATHING_NO_HALT;
803 // Enable breathing interrupt
804 TIMSK1 |= _BV(OCIE1A);
807 void breathing_pulse(void)
809 if (get_backlight_level() == 0)
815 // Set breathing_index to be at the midpoint + 1 (brightest point)
816 breathing_index = 0x21 << breath_speed;
819 breathing_halt = BREATHING_HALT_ON;
821 // Enable breathing interrupt
822 TIMSK1 |= _BV(OCIE1A);
825 void breathing_disable(void)
827 // Disable breathing interrupt
828 TIMSK1 &= ~_BV(OCIE1A);
829 backlight_set(get_backlight_level());
832 void breathing_self_disable(void)
834 if (get_backlight_level() == 0)
836 breathing_halt = BREATHING_HALT_OFF;
840 breathing_halt = BREATHING_HALT_ON;
843 //backlight_set(get_backlight_level());
846 void breathing_toggle(void)
850 if (get_backlight_level() == 0)
856 // Set breathing_index to be at the midpoint + 1 (brightest point)
857 breathing_index = 0x21 << breath_speed;
860 breathing_halt = BREATHING_NO_HALT;
863 // Toggle breathing interrupt
864 TIMSK1 ^= _BV(OCIE1A);
866 // Restore backlight level
869 backlight_set(get_backlight_level());
873 bool is_breathing(void)
875 return (TIMSK1 && _BV(OCIE1A));
878 void breathing_intensity_default(void)
880 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
881 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
884 void breathing_intensity_set(uint8_t value)
886 breath_intensity = value;
889 void breathing_speed_default(void)
894 void breathing_speed_set(uint8_t value)
896 bool is_breathing_now = is_breathing();
897 uint8_t old_breath_speed = breath_speed;
899 if (is_breathing_now)
901 // Disable breathing interrupt
902 TIMSK1 &= ~_BV(OCIE1A);
905 breath_speed = value;
907 if (is_breathing_now)
909 // Adjust index to account for new speed
910 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
912 // Enable breathing interrupt
913 TIMSK1 |= _BV(OCIE1A);
918 void breathing_speed_inc(uint8_t value)
920 if ((uint16_t)(breath_speed - value) > 10 )
922 breathing_speed_set(0);
926 breathing_speed_set(breath_speed - value);
930 void breathing_speed_dec(uint8_t value)
932 if ((uint16_t)(breath_speed + value) > 10 )
934 breathing_speed_set(10);
938 breathing_speed_set(breath_speed + value);
942 void breathing_defaults(void)
944 breathing_intensity_default();
945 breathing_speed_default();
946 breathing_halt = BREATHING_NO_HALT;
949 /* Breathing Sleep LED brighness(PWM On period) table
950 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
952 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
953 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
955 static const uint8_t breathing_table[64] PROGMEM = {
956 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
957 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
958 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
959 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
962 ISR(TIMER1_COMPA_vect)
964 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
967 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
969 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
971 // Disable breathing interrupt
972 TIMSK1 &= ~_BV(OCIE1A);
975 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
985 __attribute__ ((weak))
986 void backlight_init_ports(void)
991 __attribute__ ((weak))
992 void backlight_set(uint8_t level)
1000 // Functions for spitting out values
1003 void send_dword(uint32_t number) { // this might not actually work
1004 uint16_t word = (number >> 16);
1006 send_word(number & 0xFFFFUL);
1009 void send_word(uint16_t number) {
1010 uint8_t byte = number >> 8;
1012 send_byte(number & 0xFF);
1015 void send_byte(uint8_t number) {
1016 uint8_t nibble = number >> 4;
1017 send_nibble(nibble);
1018 send_nibble(number & 0xF);
1021 void send_nibble(uint8_t number) {
1024 register_code(KC_0);
1025 unregister_code(KC_0);
1028 register_code(KC_1 + (number - 1));
1029 unregister_code(KC_1 + (number - 1));
1032 register_code(KC_A + (number - 0xA));
1033 unregister_code(KC_A + (number - 0xA));
1039 __attribute__((weak))
1040 uint16_t hex_to_keycode(uint8_t hex)
1044 } else if (hex < 0xA) {
1045 return KC_1 + (hex - 0x1);
1047 return KC_A + (hex - 0xA);
1051 void api_send_unicode(uint32_t unicode) {
1054 dword_to_bytes(unicode, chunk);
1055 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1059 __attribute__ ((weak))
1060 void led_set_user(uint8_t usb_led) {
1064 __attribute__ ((weak))
1065 void led_set_kb(uint8_t usb_led) {
1066 led_set_user(usb_led);
1069 __attribute__ ((weak))
1070 void led_init_ports(void)
1075 __attribute__ ((weak))
1076 void led_set(uint8_t usb_led)
1081 // // Using PE6 Caps Lock LED
1082 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1092 // PORTE &= ~(1<<6);
1095 led_set_kb(usb_led);
1099 //------------------------------------------------------------------------------
1100 // Override these functions in your keymap file to play different tunes on
1101 // different events such as startup and bootloader jump
1103 __attribute__ ((weak))
1104 void startup_user() {}
1106 __attribute__ ((weak))
1107 void shutdown_user() {}
1109 //------------------------------------------------------------------------------