3 #include "outputselect.h"
7 #define TAPPING_TERM 200
10 #include "backlight.h"
11 extern backlight_config_t backlight_config;
13 #ifdef FAUXCLICKY_ENABLE
14 #include "fauxclicky.h"
17 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
19 case QK_MODS ... QK_MODS_MAX:
34 if (code < QK_RMODS_MIN) return;
46 static inline void qk_register_weak_mods(uint8_t kc) {
47 add_weak_mods(MOD_BIT(kc));
48 send_keyboard_report();
51 static inline void qk_unregister_weak_mods(uint8_t kc) {
52 del_weak_mods(MOD_BIT(kc));
53 send_keyboard_report();
56 static inline void qk_register_mods(uint8_t kc) {
57 add_weak_mods(MOD_BIT(kc));
58 send_keyboard_report();
61 static inline void qk_unregister_mods(uint8_t kc) {
62 del_weak_mods(MOD_BIT(kc));
63 send_keyboard_report();
66 void register_code16 (uint16_t code) {
67 if (IS_MOD(code) || code == KC_NO) {
68 do_code16 (code, qk_register_mods);
70 do_code16 (code, qk_register_weak_mods);
75 void unregister_code16 (uint16_t code) {
76 unregister_code (code);
77 if (IS_MOD(code) || code == KC_NO) {
78 do_code16 (code, qk_unregister_mods);
80 do_code16 (code, qk_unregister_weak_mods);
84 __attribute__ ((weak))
85 bool process_action_kb(keyrecord_t *record) {
89 __attribute__ ((weak))
90 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
91 return process_record_user(keycode, record);
94 __attribute__ ((weak))
95 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
99 void reset_keyboard(void) {
106 #ifdef CATERINA_BOOTLOADER
107 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
112 // Shift / paren setup
115 #define LSPO_KEY KC_9
118 #define RSPC_KEY KC_0
121 static bool shift_interrupted[2] = {0, 0};
122 static uint16_t scs_timer = 0;
124 bool process_record_quantum(keyrecord_t *record) {
126 /* This gets the keycode from the key pressed */
127 keypos_t key = record->event.key;
130 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
131 /* TODO: Use store_or_get_action() or a similar function. */
132 if (!disable_action_cache) {
135 if (record->event.pressed) {
136 layer = layer_switch_get_layer(key);
137 update_source_layers_cache(key, layer);
139 layer = read_source_layers_cache(key);
141 keycode = keymap_key_to_keycode(layer, key);
144 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
146 // This is how you use actions here
147 // if (keycode == KC_LEAD) {
149 // action.code = ACTION_DEFAULT_LAYER_SET(0);
150 // process_action(record, action);
155 process_record_kb(keycode, record) &&
157 process_midi(keycode, record) &&
160 process_music(keycode, record) &&
162 #ifdef TAP_DANCE_ENABLE
163 process_tap_dance(keycode, record) &&
165 #ifndef DISABLE_LEADER
166 process_leader(keycode, record) &&
168 #ifndef DISABLE_CHORDING
169 process_chording(keycode, record) &&
172 process_combo(keycode, record) &&
174 #ifdef UNICODE_ENABLE
175 process_unicode(keycode, record) &&
178 process_ucis(keycode, record) &&
180 #ifdef PRINTING_ENABLE
181 process_printer(keycode, record) &&
183 #ifdef UNICODEMAP_ENABLE
184 process_unicode_map(keycode, record) &&
190 // Shift / paren setup
194 if (record->event.pressed) {
200 if (record->event.pressed) {
201 print("\nDEBUG: enabled.\n");
206 #ifdef FAUXCLICKY_ENABLE
208 if (record->event.pressed) {
214 if (record->event.pressed) {
220 if (record->event.pressed) {
226 #ifdef RGBLIGHT_ENABLE
228 if (record->event.pressed) {
234 if (record->event.pressed) {
240 if (record->event.pressed) {
241 rgblight_increase_hue();
246 if (record->event.pressed) {
247 rgblight_decrease_hue();
252 if (record->event.pressed) {
253 rgblight_increase_sat();
258 if (record->event.pressed) {
259 rgblight_decrease_sat();
264 if (record->event.pressed) {
265 rgblight_increase_val();
270 if (record->event.pressed) {
271 rgblight_decrease_val();
278 if (record->event.pressed) {
279 set_output(OUTPUT_AUTO);
284 if (record->event.pressed) {
285 set_output(OUTPUT_USB);
289 #ifdef BLUETOOTH_ENABLE
291 if (record->event.pressed) {
292 set_output(OUTPUT_BLUETOOTH);
297 #ifdef ADAFRUIT_BLE_ENABLE
299 if (record->event.pressed) {
300 set_output(OUTPUT_ADAFRUIT_BLE);
306 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
307 if (record->event.pressed) {
308 // MAGIC actions (BOOTMAGIC without the boot)
309 if (!eeconfig_is_enabled()) {
313 keymap_config.raw = eeconfig_read_keymap();
316 case MAGIC_SWAP_CONTROL_CAPSLOCK:
317 keymap_config.swap_control_capslock = true;
319 case MAGIC_CAPSLOCK_TO_CONTROL:
320 keymap_config.capslock_to_control = true;
322 case MAGIC_SWAP_LALT_LGUI:
323 keymap_config.swap_lalt_lgui = true;
325 case MAGIC_SWAP_RALT_RGUI:
326 keymap_config.swap_ralt_rgui = true;
329 keymap_config.no_gui = true;
331 case MAGIC_SWAP_GRAVE_ESC:
332 keymap_config.swap_grave_esc = true;
334 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
335 keymap_config.swap_backslash_backspace = true;
337 case MAGIC_HOST_NKRO:
338 keymap_config.nkro = true;
340 case MAGIC_SWAP_ALT_GUI:
341 keymap_config.swap_lalt_lgui = true;
342 keymap_config.swap_ralt_rgui = true;
344 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
345 keymap_config.swap_control_capslock = false;
347 case MAGIC_UNCAPSLOCK_TO_CONTROL:
348 keymap_config.capslock_to_control = false;
350 case MAGIC_UNSWAP_LALT_LGUI:
351 keymap_config.swap_lalt_lgui = false;
353 case MAGIC_UNSWAP_RALT_RGUI:
354 keymap_config.swap_ralt_rgui = false;
357 keymap_config.no_gui = false;
359 case MAGIC_UNSWAP_GRAVE_ESC:
360 keymap_config.swap_grave_esc = false;
362 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
363 keymap_config.swap_backslash_backspace = false;
365 case MAGIC_UNHOST_NKRO:
366 keymap_config.nkro = false;
368 case MAGIC_UNSWAP_ALT_GUI:
369 keymap_config.swap_lalt_lgui = false;
370 keymap_config.swap_ralt_rgui = false;
372 case MAGIC_TOGGLE_NKRO:
373 keymap_config.nkro = !keymap_config.nkro;
378 eeconfig_update_keymap(keymap_config.raw);
379 clear_keyboard(); // clear to prevent stuck keys
385 if (record->event.pressed) {
386 shift_interrupted[0] = false;
387 scs_timer = timer_read ();
388 register_mods(MOD_BIT(KC_LSFT));
391 #ifdef DISABLE_SPACE_CADET_ROLLOVER
392 if (get_mods() & MOD_BIT(KC_RSFT)) {
393 shift_interrupted[0] = true;
394 shift_interrupted[1] = true;
397 if (!shift_interrupted[0] && timer_elapsed(scs_timer) < TAPPING_TERM) {
398 register_code(LSPO_KEY);
399 unregister_code(LSPO_KEY);
401 unregister_mods(MOD_BIT(KC_LSFT));
408 if (record->event.pressed) {
409 shift_interrupted[1] = false;
410 scs_timer = timer_read ();
411 register_mods(MOD_BIT(KC_RSFT));
414 #ifdef DISABLE_SPACE_CADET_ROLLOVER
415 if (get_mods() & MOD_BIT(KC_LSFT)) {
416 shift_interrupted[0] = true;
417 shift_interrupted[1] = true;
420 if (!shift_interrupted[1] && timer_elapsed(scs_timer) < TAPPING_TERM) {
421 register_code(RSPC_KEY);
422 unregister_code(RSPC_KEY);
424 unregister_mods(MOD_BIT(KC_RSFT));
430 shift_interrupted[0] = true;
431 shift_interrupted[1] = true;
436 return process_action_kb(record);
439 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
440 0, 0, 0, 0, 0, 0, 0, 0,
441 0, 0, 0, 0, 0, 0, 0, 0,
442 0, 0, 0, 0, 0, 0, 0, 0,
443 0, 0, 0, 0, 0, 0, 0, 0,
444 0, 1, 1, 1, 1, 1, 1, 0,
445 1, 1, 1, 1, 0, 0, 0, 0,
446 0, 0, 0, 0, 0, 0, 0, 0,
447 0, 0, 1, 0, 1, 0, 1, 1,
448 1, 1, 1, 1, 1, 1, 1, 1,
449 1, 1, 1, 1, 1, 1, 1, 1,
450 1, 1, 1, 1, 1, 1, 1, 1,
451 1, 1, 1, 0, 0, 0, 1, 1,
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, 0, 0, 1, 1, 1, 1, 0
458 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
459 0, 0, 0, 0, 0, 0, 0, 0,
460 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
461 0, 0, 0, 0, 0, 0, 0, 0,
462 0, 0, 0, KC_ESC, 0, 0, 0, 0,
463 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
464 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
465 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
466 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
467 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
468 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
469 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
470 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
471 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
472 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
473 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
474 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
477 /* for users whose OSes are set to Colemak */
479 #include "keymap_colemak.h"
481 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
482 0, 0, 0, 0, 0, 0, 0, 0,
483 0, 0, 0, 0, 0, 0, 0, 0,
484 0, 0, 0, 0, 0, 0, 0, 0,
485 0, 0, 0, 0, 0, 0, 0, 0,
486 0, 1, 1, 1, 1, 1, 1, 0,
487 1, 1, 1, 1, 0, 0, 0, 0,
488 0, 0, 0, 0, 0, 0, 0, 0,
489 0, 0, 1, 0, 1, 0, 1, 1,
490 1, 1, 1, 1, 1, 1, 1, 1,
491 1, 1, 1, 1, 1, 1, 1, 1,
492 1, 1, 1, 1, 1, 1, 1, 1,
493 1, 1, 1, 0, 0, 0, 1, 1,
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, 0, 0, 1, 1, 1, 1, 0
500 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
501 0, 0, 0, 0, 0, 0, 0, 0,
502 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
503 0, 0, 0, 0, 0, 0, 0, 0,
504 0, 0, 0, KC_ESC, 0, 0, 0, 0,
505 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
506 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
507 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
508 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
509 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
510 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
511 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
512 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
513 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
514 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
515 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
516 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
521 void send_string(const char *str) {
524 uint8_t ascii_code = pgm_read_byte(str);
525 if (!ascii_code) break;
526 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
527 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
528 register_code(KC_LSFT);
529 register_code(keycode);
530 unregister_code(keycode);
531 unregister_code(KC_LSFT);
534 register_code(keycode);
535 unregister_code(keycode);
541 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
542 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
549 void tap_random_base64(void) {
550 #if defined(__AVR_ATmega32U4__)
551 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
553 uint8_t key = rand() % 64;
557 register_code(KC_LSFT);
558 register_code(key + KC_A);
559 unregister_code(key + KC_A);
560 unregister_code(KC_LSFT);
563 register_code(key - 26 + KC_A);
564 unregister_code(key - 26 + KC_A);
568 unregister_code(KC_0);
571 register_code(key - 53 + KC_1);
572 unregister_code(key - 53 + KC_1);
575 register_code(KC_LSFT);
576 register_code(KC_EQL);
577 unregister_code(KC_EQL);
578 unregister_code(KC_LSFT);
581 register_code(KC_SLSH);
582 unregister_code(KC_SLSH);
587 void matrix_init_quantum() {
588 #ifdef BACKLIGHT_ENABLE
589 backlight_init_ports();
594 void matrix_scan_quantum() {
599 #ifdef TAP_DANCE_ENABLE
600 matrix_scan_tap_dance();
607 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
614 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
616 static const uint8_t backlight_pin = BACKLIGHT_PIN;
618 #if BACKLIGHT_PIN == B7
619 # define COM1x1 COM1C1
621 #elif BACKLIGHT_PIN == B6
622 # define COM1x1 COM1B1
624 #elif BACKLIGHT_PIN == B5
625 # define COM1x1 COM1A1
628 # define NO_BACKLIGHT_CLOCK
631 #ifndef BACKLIGHT_ON_STATE
632 #define BACKLIGHT_ON_STATE 0
635 __attribute__ ((weak))
636 void backlight_init_ports(void)
639 // Setup backlight pin as output and output to on state.
641 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
642 #if BACKLIGHT_ON_STATE == 0
644 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
647 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
650 #ifndef NO_BACKLIGHT_CLOCK
651 // Use full 16-bit resolution.
654 // I could write a wall of text here to explain... but TL;DW
655 // Go read the ATmega32u4 datasheet.
656 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
658 // Pin PB7 = OCR1C (Timer 1, Channel C)
659 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
660 // (i.e. start high, go low when counter matches.)
661 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
662 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
664 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
665 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
669 #ifdef BACKLIGHT_BREATHING
670 breathing_defaults();
674 __attribute__ ((weak))
675 void backlight_set(uint8_t level)
677 // Prevent backlight blink on lowest level
678 // #if BACKLIGHT_ON_STATE == 0
680 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
683 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
687 #ifndef NO_BACKLIGHT_CLOCK
688 // Turn off PWM control on backlight pin, revert to output low.
689 TCCR1A &= ~(_BV(COM1x1));
692 // #if BACKLIGHT_ON_STATE == 0
694 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
697 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
701 #ifndef NO_BACKLIGHT_CLOCK
702 else if ( level == BACKLIGHT_LEVELS ) {
703 // Turn on PWM control of backlight pin
704 TCCR1A |= _BV(COM1x1);
705 // Set the brightness
709 // Turn on PWM control of backlight pin
710 TCCR1A |= _BV(COM1x1);
711 // Set the brightness
712 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
716 #ifdef BACKLIGHT_BREATHING
717 breathing_intensity_default();
721 uint8_t backlight_tick = 0;
723 void backlight_task(void) {
724 #ifdef NO_BACKLIGHT_CLOCK
725 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
726 #if BACKLIGHT_ON_STATE == 0
728 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
731 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
734 #if BACKLIGHT_ON_STATE == 0
736 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
739 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
742 backlight_tick = (backlight_tick + 1) % 16;
746 #ifdef BACKLIGHT_BREATHING
748 #define BREATHING_NO_HALT 0
749 #define BREATHING_HALT_OFF 1
750 #define BREATHING_HALT_ON 2
752 static uint8_t breath_intensity;
753 static uint8_t breath_speed;
754 static uint16_t breathing_index;
755 static uint8_t breathing_halt;
757 void breathing_enable(void)
759 if (get_backlight_level() == 0)
765 // Set breathing_index to be at the midpoint (brightest point)
766 breathing_index = 0x20 << breath_speed;
769 breathing_halt = BREATHING_NO_HALT;
771 // Enable breathing interrupt
772 TIMSK1 |= _BV(OCIE1A);
775 void breathing_pulse(void)
777 if (get_backlight_level() == 0)
783 // Set breathing_index to be at the midpoint + 1 (brightest point)
784 breathing_index = 0x21 << breath_speed;
787 breathing_halt = BREATHING_HALT_ON;
789 // Enable breathing interrupt
790 TIMSK1 |= _BV(OCIE1A);
793 void breathing_disable(void)
795 // Disable breathing interrupt
796 TIMSK1 &= ~_BV(OCIE1A);
797 backlight_set(get_backlight_level());
800 void breathing_self_disable(void)
802 if (get_backlight_level() == 0)
804 breathing_halt = BREATHING_HALT_OFF;
808 breathing_halt = BREATHING_HALT_ON;
811 //backlight_set(get_backlight_level());
814 void breathing_toggle(void)
818 if (get_backlight_level() == 0)
824 // Set breathing_index to be at the midpoint + 1 (brightest point)
825 breathing_index = 0x21 << breath_speed;
828 breathing_halt = BREATHING_NO_HALT;
831 // Toggle breathing interrupt
832 TIMSK1 ^= _BV(OCIE1A);
834 // Restore backlight level
837 backlight_set(get_backlight_level());
841 bool is_breathing(void)
843 return (TIMSK1 && _BV(OCIE1A));
846 void breathing_intensity_default(void)
848 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
849 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
852 void breathing_intensity_set(uint8_t value)
854 breath_intensity = value;
857 void breathing_speed_default(void)
862 void breathing_speed_set(uint8_t value)
864 bool is_breathing_now = is_breathing();
865 uint8_t old_breath_speed = breath_speed;
867 if (is_breathing_now)
869 // Disable breathing interrupt
870 TIMSK1 &= ~_BV(OCIE1A);
873 breath_speed = value;
875 if (is_breathing_now)
877 // Adjust index to account for new speed
878 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
880 // Enable breathing interrupt
881 TIMSK1 |= _BV(OCIE1A);
886 void breathing_speed_inc(uint8_t value)
888 if ((uint16_t)(breath_speed - value) > 10 )
890 breathing_speed_set(0);
894 breathing_speed_set(breath_speed - value);
898 void breathing_speed_dec(uint8_t value)
900 if ((uint16_t)(breath_speed + value) > 10 )
902 breathing_speed_set(10);
906 breathing_speed_set(breath_speed + value);
910 void breathing_defaults(void)
912 breathing_intensity_default();
913 breathing_speed_default();
914 breathing_halt = BREATHING_NO_HALT;
917 /* Breathing Sleep LED brighness(PWM On period) table
918 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
920 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
921 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
923 static const uint8_t breathing_table[64] PROGMEM = {
924 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
925 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
926 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
927 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
930 ISR(TIMER1_COMPA_vect)
932 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
935 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
937 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
939 // Disable breathing interrupt
940 TIMSK1 &= ~_BV(OCIE1A);
943 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
953 __attribute__ ((weak))
954 void backlight_init_ports(void)
959 __attribute__ ((weak))
960 void backlight_set(uint8_t level)
968 // Functions for spitting out values
971 void send_dword(uint32_t number) { // this might not actually work
972 uint16_t word = (number >> 16);
974 send_word(number & 0xFFFFUL);
977 void send_word(uint16_t number) {
978 uint8_t byte = number >> 8;
980 send_byte(number & 0xFF);
983 void send_byte(uint8_t number) {
984 uint8_t nibble = number >> 4;
986 send_nibble(number & 0xF);
989 void send_nibble(uint8_t number) {
993 unregister_code(KC_0);
996 register_code(KC_1 + (number - 1));
997 unregister_code(KC_1 + (number - 1));
1000 register_code(KC_A + (number - 0xA));
1001 unregister_code(KC_A + (number - 0xA));
1007 __attribute__((weak))
1008 uint16_t hex_to_keycode(uint8_t hex)
1012 } else if (hex < 0xA) {
1013 return KC_1 + (hex - 0x1);
1015 return KC_A + (hex - 0xA);
1019 void api_send_unicode(uint32_t unicode) {
1022 dword_to_bytes(unicode, chunk);
1023 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1027 __attribute__ ((weak))
1028 void led_set_user(uint8_t usb_led) {
1032 __attribute__ ((weak))
1033 void led_set_kb(uint8_t usb_led) {
1034 led_set_user(usb_led);
1037 __attribute__ ((weak))
1038 void led_init_ports(void)
1043 __attribute__ ((weak))
1044 void led_set(uint8_t usb_led)
1049 // // Using PE6 Caps Lock LED
1050 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1060 // PORTE &= ~(1<<6);
1063 led_set_kb(usb_led);
1067 //------------------------------------------------------------------------------
1068 // Override these functions in your keymap file to play different tunes on
1069 // different events such as startup and bootloader jump
1071 __attribute__ ((weak))
1072 void startup_user() {}
1074 __attribute__ ((weak))
1075 void shutdown_user() {}
1077 //------------------------------------------------------------------------------