3 #include "outputselect.h"
7 #define TAPPING_TERM 200
10 #ifdef FAUXCLICKY_ENABLE
11 #include "fauxclicky.h"
14 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
16 case QK_MODS ... QK_MODS_MAX:
31 if (code < QK_RMODS_MIN) return;
43 static inline void qk_register_weak_mods(uint8_t kc) {
44 add_weak_mods(MOD_BIT(kc));
45 send_keyboard_report();
48 static inline void qk_unregister_weak_mods(uint8_t kc) {
49 del_weak_mods(MOD_BIT(kc));
50 send_keyboard_report();
53 static inline void qk_register_mods(uint8_t kc) {
54 add_weak_mods(MOD_BIT(kc));
55 send_keyboard_report();
58 static inline void qk_unregister_mods(uint8_t kc) {
59 del_weak_mods(MOD_BIT(kc));
60 send_keyboard_report();
63 void register_code16 (uint16_t code) {
64 if (IS_MOD(code) || code == KC_NO) {
65 do_code16 (code, qk_register_mods);
67 do_code16 (code, qk_register_weak_mods);
72 void unregister_code16 (uint16_t code) {
73 unregister_code (code);
74 if (IS_MOD(code) || code == KC_NO) {
75 do_code16 (code, qk_unregister_mods);
77 do_code16 (code, qk_unregister_weak_mods);
81 __attribute__ ((weak))
82 bool process_action_kb(keyrecord_t *record) {
86 __attribute__ ((weak))
87 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
88 return process_record_user(keycode, record);
91 __attribute__ ((weak))
92 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
96 void reset_keyboard(void) {
98 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
99 music_all_notes_off();
103 #ifdef CATERINA_BOOTLOADER
104 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
109 // Shift / paren setup
112 #define LSPO_KEY KC_9
115 #define RSPC_KEY KC_0
118 static bool shift_interrupted[2] = {0, 0};
119 static uint16_t scs_timer = 0;
121 bool process_record_quantum(keyrecord_t *record) {
123 /* This gets the keycode from the key pressed */
124 keypos_t key = record->event.key;
127 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
128 /* TODO: Use store_or_get_action() or a similar function. */
129 if (!disable_action_cache) {
132 if (record->event.pressed) {
133 layer = layer_switch_get_layer(key);
134 update_source_layers_cache(key, layer);
136 layer = read_source_layers_cache(key);
138 keycode = keymap_key_to_keycode(layer, key);
141 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
143 // This is how you use actions here
144 // if (keycode == KC_LEAD) {
146 // action.code = ACTION_DEFAULT_LAYER_SET(0);
147 // process_action(record, action);
152 process_record_kb(keycode, record) &&
153 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
154 process_midi(keycode, record) &&
157 process_audio(keycode, record) &&
159 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
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();
610 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
612 static const uint8_t backlight_pin = BACKLIGHT_PIN;
614 #if BACKLIGHT_PIN == B7
615 # define COM1x1 COM1C1
617 #elif BACKLIGHT_PIN == B6
618 # define COM1x1 COM1B1
620 #elif BACKLIGHT_PIN == B5
621 # define COM1x1 COM1A1
624 # define NO_BACKLIGHT_CLOCK
627 #ifndef BACKLIGHT_ON_STATE
628 #define BACKLIGHT_ON_STATE 0
631 __attribute__ ((weak))
632 void backlight_init_ports(void)
635 // Setup backlight pin as output and output to on state.
637 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
638 #if BACKLIGHT_ON_STATE == 0
640 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
643 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
646 #ifndef NO_BACKLIGHT_CLOCK
647 // Use full 16-bit resolution.
650 // I could write a wall of text here to explain... but TL;DW
651 // Go read the ATmega32u4 datasheet.
652 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
654 // Pin PB7 = OCR1C (Timer 1, Channel C)
655 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
656 // (i.e. start high, go low when counter matches.)
657 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
658 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
660 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
661 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
665 #ifdef BACKLIGHT_BREATHING
666 breathing_defaults();
670 __attribute__ ((weak))
671 void backlight_set(uint8_t level)
673 // Prevent backlight blink on lowest level
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);
683 #ifndef NO_BACKLIGHT_CLOCK
684 // Turn off PWM control on backlight pin, revert to output low.
685 TCCR1A &= ~(_BV(COM1x1));
688 #if BACKLIGHT_ON_STATE == 0
690 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
693 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
697 #ifndef NO_BACKLIGHT_CLOCK
698 else if ( level == BACKLIGHT_LEVELS ) {
699 // Turn on PWM control of backlight pin
700 TCCR1A |= _BV(COM1x1);
701 // Set the brightness
705 // Turn on PWM control of backlight pin
706 TCCR1A |= _BV(COM1x1);
707 // Set the brightness
708 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
712 #ifdef BACKLIGHT_BREATHING
713 breathing_intensity_default();
718 #ifdef BACKLIGHT_BREATHING
720 #define BREATHING_NO_HALT 0
721 #define BREATHING_HALT_OFF 1
722 #define BREATHING_HALT_ON 2
724 static uint8_t breath_intensity;
725 static uint8_t breath_speed;
726 static uint16_t breathing_index;
727 static uint8_t breathing_halt;
729 void breathing_enable(void)
731 if (get_backlight_level() == 0)
737 // Set breathing_index to be at the midpoint (brightest point)
738 breathing_index = 0x20 << breath_speed;
741 breathing_halt = BREATHING_NO_HALT;
743 // Enable breathing interrupt
744 TIMSK1 |= _BV(OCIE1A);
747 void breathing_pulse(void)
749 if (get_backlight_level() == 0)
755 // Set breathing_index to be at the midpoint + 1 (brightest point)
756 breathing_index = 0x21 << breath_speed;
759 breathing_halt = BREATHING_HALT_ON;
761 // Enable breathing interrupt
762 TIMSK1 |= _BV(OCIE1A);
765 void breathing_disable(void)
767 // Disable breathing interrupt
768 TIMSK1 &= ~_BV(OCIE1A);
769 backlight_set(get_backlight_level());
772 void breathing_self_disable(void)
774 if (get_backlight_level() == 0)
776 breathing_halt = BREATHING_HALT_OFF;
780 breathing_halt = BREATHING_HALT_ON;
783 //backlight_set(get_backlight_level());
786 void breathing_toggle(void)
790 if (get_backlight_level() == 0)
796 // Set breathing_index to be at the midpoint + 1 (brightest point)
797 breathing_index = 0x21 << breath_speed;
800 breathing_halt = BREATHING_NO_HALT;
803 // Toggle breathing interrupt
804 TIMSK1 ^= _BV(OCIE1A);
806 // Restore backlight level
809 backlight_set(get_backlight_level());
813 bool is_breathing(void)
815 return (TIMSK1 && _BV(OCIE1A));
818 void breathing_intensity_default(void)
820 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
821 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
824 void breathing_intensity_set(uint8_t value)
826 breath_intensity = value;
829 void breathing_speed_default(void)
834 void breathing_speed_set(uint8_t value)
836 bool is_breathing_now = is_breathing();
837 uint8_t old_breath_speed = breath_speed;
839 if (is_breathing_now)
841 // Disable breathing interrupt
842 TIMSK1 &= ~_BV(OCIE1A);
845 breath_speed = value;
847 if (is_breathing_now)
849 // Adjust index to account for new speed
850 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
852 // Enable breathing interrupt
853 TIMSK1 |= _BV(OCIE1A);
858 void breathing_speed_inc(uint8_t value)
860 if ((uint16_t)(breath_speed - value) > 10 )
862 breathing_speed_set(0);
866 breathing_speed_set(breath_speed - value);
870 void breathing_speed_dec(uint8_t value)
872 if ((uint16_t)(breath_speed + value) > 10 )
874 breathing_speed_set(10);
878 breathing_speed_set(breath_speed + value);
882 void breathing_defaults(void)
884 breathing_intensity_default();
885 breathing_speed_default();
886 breathing_halt = BREATHING_NO_HALT;
889 /* Breathing Sleep LED brighness(PWM On period) table
890 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
892 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
893 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
895 static const uint8_t breathing_table[64] PROGMEM = {
896 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
897 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
898 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
899 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
902 ISR(TIMER1_COMPA_vect)
904 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
907 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
909 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
911 // Disable breathing interrupt
912 TIMSK1 &= ~_BV(OCIE1A);
915 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
925 __attribute__ ((weak))
926 void backlight_init_ports(void)
931 __attribute__ ((weak))
932 void backlight_set(uint8_t level)
940 // Functions for spitting out values
943 void send_dword(uint32_t number) { // this might not actually work
944 uint16_t word = (number >> 16);
946 send_word(number & 0xFFFFUL);
949 void send_word(uint16_t number) {
950 uint8_t byte = number >> 8;
952 send_byte(number & 0xFF);
955 void send_byte(uint8_t number) {
956 uint8_t nibble = number >> 4;
958 send_nibble(number & 0xF);
961 void send_nibble(uint8_t number) {
965 unregister_code(KC_0);
968 register_code(KC_1 + (number - 1));
969 unregister_code(KC_1 + (number - 1));
972 register_code(KC_A + (number - 0xA));
973 unregister_code(KC_A + (number - 0xA));
979 __attribute__((weak))
980 uint16_t hex_to_keycode(uint8_t hex)
984 } else if (hex < 0xA) {
985 return KC_1 + (hex - 0x1);
987 return KC_A + (hex - 0xA);
991 void api_send_unicode(uint32_t unicode) {
994 dword_to_bytes(unicode, chunk);
995 MT_SEND_DATA(DT_UNICODE, chunk, 5);
999 __attribute__ ((weak))
1000 void led_set_user(uint8_t usb_led) {
1004 __attribute__ ((weak))
1005 void led_set_kb(uint8_t usb_led) {
1006 led_set_user(usb_led);
1009 __attribute__ ((weak))
1010 void led_init_ports(void)
1015 __attribute__ ((weak))
1016 void led_set(uint8_t usb_led)
1021 // // Using PE6 Caps Lock LED
1022 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1032 // PORTE &= ~(1<<6);
1035 led_set_kb(usb_led);
1039 //------------------------------------------------------------------------------
1040 // Override these functions in your keymap file to play different tunes on
1041 // different events such as startup and bootloader jump
1043 __attribute__ ((weak))
1044 void startup_user() {}
1046 __attribute__ ((weak))
1047 void shutdown_user() {}
1049 //------------------------------------------------------------------------------