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 void (*method)(uint8_t) = (record->event.pressed) ? &add_key : &del_key;
442 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
443 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
445 method(shifted ? KC_GRAVE : KC_ESCAPE);
446 send_keyboard_report();
449 shift_interrupted[0] = true;
450 shift_interrupted[1] = true;
455 return process_action_kb(record);
458 __attribute__ ((weak))
459 const bool ascii_to_shift_lut[0x80] PROGMEM = {
460 0, 0, 0, 0, 0, 0, 0, 0,
461 0, 0, 0, 0, 0, 0, 0, 0,
462 0, 0, 0, 0, 0, 0, 0, 0,
463 0, 0, 0, 0, 0, 0, 0, 0,
464 0, 1, 1, 1, 1, 1, 1, 0,
465 1, 1, 1, 1, 0, 0, 0, 0,
466 0, 0, 0, 0, 0, 0, 0, 0,
467 0, 0, 1, 0, 1, 0, 1, 1,
468 1, 1, 1, 1, 1, 1, 1, 1,
469 1, 1, 1, 1, 1, 1, 1, 1,
470 1, 1, 1, 1, 1, 1, 1, 1,
471 1, 1, 1, 0, 0, 0, 1, 1,
472 0, 0, 0, 0, 0, 0, 0, 0,
473 0, 0, 0, 0, 0, 0, 0, 0,
474 0, 0, 0, 0, 0, 0, 0, 0,
475 0, 0, 0, 1, 1, 1, 1, 0
478 __attribute__ ((weak))
479 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
480 0, 0, 0, 0, 0, 0, 0, 0,
481 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
482 0, 0, 0, 0, 0, 0, 0, 0,
483 0, 0, 0, KC_ESC, 0, 0, 0, 0,
484 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
485 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
486 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
487 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
488 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
489 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
490 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
491 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
492 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
493 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
494 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
495 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
498 void send_string(const char *str) {
499 send_string_with_delay(str, 0);
502 void send_string_with_delay(const char *str, uint8_t interval) {
505 uint8_t ascii_code = pgm_read_byte(str);
506 if (!ascii_code) break;
507 keycode = pgm_read_byte(&ascii_to_keycode_lut[ascii_code]);
508 if (pgm_read_byte(&ascii_to_shift_lut[ascii_code])) {
509 register_code(KC_LSFT);
510 register_code(keycode);
511 unregister_code(keycode);
512 unregister_code(KC_LSFT);
515 register_code(keycode);
516 unregister_code(keycode);
520 { uint8_t ms = interval; while (ms--) wait_ms(1); }
524 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
525 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
532 void tap_random_base64(void) {
533 #if defined(__AVR_ATmega32U4__)
534 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
536 uint8_t key = rand() % 64;
540 register_code(KC_LSFT);
541 register_code(key + KC_A);
542 unregister_code(key + KC_A);
543 unregister_code(KC_LSFT);
546 register_code(key - 26 + KC_A);
547 unregister_code(key - 26 + KC_A);
551 unregister_code(KC_0);
554 register_code(key - 53 + KC_1);
555 unregister_code(key - 53 + KC_1);
558 register_code(KC_LSFT);
559 register_code(KC_EQL);
560 unregister_code(KC_EQL);
561 unregister_code(KC_LSFT);
564 register_code(KC_SLSH);
565 unregister_code(KC_SLSH);
570 void matrix_init_quantum() {
571 #ifdef BACKLIGHT_ENABLE
572 backlight_init_ports();
577 void matrix_scan_quantum() {
582 #ifdef TAP_DANCE_ENABLE
583 matrix_scan_tap_dance();
590 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
597 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
599 static const uint8_t backlight_pin = BACKLIGHT_PIN;
601 #if BACKLIGHT_PIN == B7
602 # define COM1x1 COM1C1
604 #elif BACKLIGHT_PIN == B6
605 # define COM1x1 COM1B1
607 #elif BACKLIGHT_PIN == B5
608 # define COM1x1 COM1A1
611 # define NO_BACKLIGHT_CLOCK
614 #ifndef BACKLIGHT_ON_STATE
615 #define BACKLIGHT_ON_STATE 0
618 __attribute__ ((weak))
619 void backlight_init_ports(void)
622 // Setup backlight pin as output and output to on state.
624 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
625 #if BACKLIGHT_ON_STATE == 0
627 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
630 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
633 #ifndef NO_BACKLIGHT_CLOCK
634 // Use full 16-bit resolution.
637 // I could write a wall of text here to explain... but TL;DW
638 // Go read the ATmega32u4 datasheet.
639 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
641 // Pin PB7 = OCR1C (Timer 1, Channel C)
642 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
643 // (i.e. start high, go low when counter matches.)
644 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
645 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
647 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
648 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
652 #ifdef BACKLIGHT_BREATHING
653 breathing_defaults();
657 __attribute__ ((weak))
658 void backlight_set(uint8_t level)
660 // Prevent backlight blink on lowest level
661 // #if BACKLIGHT_ON_STATE == 0
663 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
666 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
670 #ifndef NO_BACKLIGHT_CLOCK
671 // Turn off PWM control on backlight pin, revert to output low.
672 TCCR1A &= ~(_BV(COM1x1));
675 // #if BACKLIGHT_ON_STATE == 0
677 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
680 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
684 #ifndef NO_BACKLIGHT_CLOCK
685 else if ( level == BACKLIGHT_LEVELS ) {
686 // Turn on PWM control of backlight pin
687 TCCR1A |= _BV(COM1x1);
688 // Set the brightness
692 // Turn on PWM control of backlight pin
693 TCCR1A |= _BV(COM1x1);
694 // Set the brightness
695 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
699 #ifdef BACKLIGHT_BREATHING
700 breathing_intensity_default();
704 uint8_t backlight_tick = 0;
706 void backlight_task(void) {
707 #ifdef NO_BACKLIGHT_CLOCK
708 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
709 #if BACKLIGHT_ON_STATE == 0
711 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
714 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
717 #if BACKLIGHT_ON_STATE == 0
719 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
722 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
725 backlight_tick = (backlight_tick + 1) % 16;
729 #ifdef BACKLIGHT_BREATHING
731 #define BREATHING_NO_HALT 0
732 #define BREATHING_HALT_OFF 1
733 #define BREATHING_HALT_ON 2
735 static uint8_t breath_intensity;
736 static uint8_t breath_speed;
737 static uint16_t breathing_index;
738 static uint8_t breathing_halt;
740 void breathing_enable(void)
742 if (get_backlight_level() == 0)
748 // Set breathing_index to be at the midpoint (brightest point)
749 breathing_index = 0x20 << breath_speed;
752 breathing_halt = BREATHING_NO_HALT;
754 // Enable breathing interrupt
755 TIMSK1 |= _BV(OCIE1A);
758 void breathing_pulse(void)
760 if (get_backlight_level() == 0)
766 // Set breathing_index to be at the midpoint + 1 (brightest point)
767 breathing_index = 0x21 << breath_speed;
770 breathing_halt = BREATHING_HALT_ON;
772 // Enable breathing interrupt
773 TIMSK1 |= _BV(OCIE1A);
776 void breathing_disable(void)
778 // Disable breathing interrupt
779 TIMSK1 &= ~_BV(OCIE1A);
780 backlight_set(get_backlight_level());
783 void breathing_self_disable(void)
785 if (get_backlight_level() == 0)
787 breathing_halt = BREATHING_HALT_OFF;
791 breathing_halt = BREATHING_HALT_ON;
794 //backlight_set(get_backlight_level());
797 void breathing_toggle(void)
801 if (get_backlight_level() == 0)
807 // Set breathing_index to be at the midpoint + 1 (brightest point)
808 breathing_index = 0x21 << breath_speed;
811 breathing_halt = BREATHING_NO_HALT;
814 // Toggle breathing interrupt
815 TIMSK1 ^= _BV(OCIE1A);
817 // Restore backlight level
820 backlight_set(get_backlight_level());
824 bool is_breathing(void)
826 return (TIMSK1 && _BV(OCIE1A));
829 void breathing_intensity_default(void)
831 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
832 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
835 void breathing_intensity_set(uint8_t value)
837 breath_intensity = value;
840 void breathing_speed_default(void)
845 void breathing_speed_set(uint8_t value)
847 bool is_breathing_now = is_breathing();
848 uint8_t old_breath_speed = breath_speed;
850 if (is_breathing_now)
852 // Disable breathing interrupt
853 TIMSK1 &= ~_BV(OCIE1A);
856 breath_speed = value;
858 if (is_breathing_now)
860 // Adjust index to account for new speed
861 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
863 // Enable breathing interrupt
864 TIMSK1 |= _BV(OCIE1A);
869 void breathing_speed_inc(uint8_t value)
871 if ((uint16_t)(breath_speed - value) > 10 )
873 breathing_speed_set(0);
877 breathing_speed_set(breath_speed - value);
881 void breathing_speed_dec(uint8_t value)
883 if ((uint16_t)(breath_speed + value) > 10 )
885 breathing_speed_set(10);
889 breathing_speed_set(breath_speed + value);
893 void breathing_defaults(void)
895 breathing_intensity_default();
896 breathing_speed_default();
897 breathing_halt = BREATHING_NO_HALT;
900 /* Breathing Sleep LED brighness(PWM On period) table
901 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
903 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
904 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
906 static const uint8_t breathing_table[64] PROGMEM = {
907 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
908 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
909 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
910 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
913 ISR(TIMER1_COMPA_vect)
915 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
918 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
920 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
922 // Disable breathing interrupt
923 TIMSK1 &= ~_BV(OCIE1A);
926 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
936 __attribute__ ((weak))
937 void backlight_init_ports(void)
942 __attribute__ ((weak))
943 void backlight_set(uint8_t level)
951 // Functions for spitting out values
954 void send_dword(uint32_t number) { // this might not actually work
955 uint16_t word = (number >> 16);
957 send_word(number & 0xFFFFUL);
960 void send_word(uint16_t number) {
961 uint8_t byte = number >> 8;
963 send_byte(number & 0xFF);
966 void send_byte(uint8_t number) {
967 uint8_t nibble = number >> 4;
969 send_nibble(number & 0xF);
972 void send_nibble(uint8_t number) {
976 unregister_code(KC_0);
979 register_code(KC_1 + (number - 1));
980 unregister_code(KC_1 + (number - 1));
983 register_code(KC_A + (number - 0xA));
984 unregister_code(KC_A + (number - 0xA));
990 __attribute__((weak))
991 uint16_t hex_to_keycode(uint8_t hex)
995 } else if (hex < 0xA) {
996 return KC_1 + (hex - 0x1);
998 return KC_A + (hex - 0xA);
1002 void api_send_unicode(uint32_t unicode) {
1005 dword_to_bytes(unicode, chunk);
1006 MT_SEND_DATA(DT_UNICODE, chunk, 5);
1010 __attribute__ ((weak))
1011 void led_set_user(uint8_t usb_led) {
1015 __attribute__ ((weak))
1016 void led_set_kb(uint8_t usb_led) {
1017 led_set_user(usb_led);
1020 __attribute__ ((weak))
1021 void led_init_ports(void)
1026 __attribute__ ((weak))
1027 void led_set(uint8_t usb_led)
1032 // // Using PE6 Caps Lock LED
1033 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1043 // PORTE &= ~(1<<6);
1046 led_set_kb(usb_led);
1050 //------------------------------------------------------------------------------
1051 // Override these functions in your keymap file to play different tunes on
1052 // different events such as startup and bootloader jump
1054 __attribute__ ((weak))
1055 void startup_user() {}
1057 __attribute__ ((weak))
1058 void shutdown_user() {}
1060 //------------------------------------------------------------------------------