4 #define TAPPING_TERM 200
7 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
9 case QK_MODS ... QK_MODS_MAX:
24 if (code < QK_RMODS_MIN) return;
36 static inline void qk_register_weak_mods(uint8_t kc) {
37 add_weak_mods(MOD_BIT(kc));
38 send_keyboard_report();
41 static inline void qk_unregister_weak_mods(uint8_t kc) {
42 del_weak_mods(MOD_BIT(kc));
43 send_keyboard_report();
46 static inline void qk_register_mods(uint8_t kc) {
47 add_weak_mods(MOD_BIT(kc));
48 send_keyboard_report();
51 static inline void qk_unregister_mods(uint8_t kc) {
52 del_weak_mods(MOD_BIT(kc));
53 send_keyboard_report();
56 void register_code16 (uint16_t code) {
57 if (IS_MOD(code) || code == KC_NO) {
58 do_code16 (code, qk_register_mods);
60 do_code16 (code, qk_register_weak_mods);
65 void unregister_code16 (uint16_t code) {
66 unregister_code (code);
67 if (IS_MOD(code) || code == KC_NO) {
68 do_code16 (code, qk_unregister_mods);
70 do_code16 (code, qk_unregister_weak_mods);
74 __attribute__ ((weak))
75 bool process_action_kb(keyrecord_t *record) {
79 __attribute__ ((weak))
80 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
81 return process_record_user(keycode, record);
84 __attribute__ ((weak))
85 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
89 void reset_keyboard(void) {
96 #ifdef CATERINA_BOOTLOADER
97 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
102 // Shift / paren setup
105 #define LSPO_KEY KC_9
108 #define RSPC_KEY KC_0
111 static bool shift_interrupted[2] = {0, 0};
112 static uint16_t scs_timer = 0;
114 bool process_record_quantum(keyrecord_t *record) {
116 /* This gets the keycode from the key pressed */
117 keypos_t key = record->event.key;
120 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
121 /* TODO: Use store_or_get_action() or a similar function. */
122 if (!disable_action_cache) {
125 if (record->event.pressed) {
126 layer = layer_switch_get_layer(key);
127 update_source_layers_cache(key, layer);
129 layer = read_source_layers_cache(key);
131 keycode = keymap_key_to_keycode(layer, key);
134 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
136 // This is how you use actions here
137 // if (keycode == KC_LEAD) {
139 // action.code = ACTION_DEFAULT_LAYER_SET(0);
140 // process_action(record, action);
145 process_record_kb(keycode, record) &&
147 process_midi(keycode, record) &&
150 process_music(keycode, record) &&
152 #ifdef TAP_DANCE_ENABLE
153 process_tap_dance(keycode, record) &&
155 #ifndef DISABLE_LEADER
156 process_leader(keycode, record) &&
158 #ifndef DISABLE_CHORDING
159 process_chording(keycode, record) &&
161 #ifdef UNICODE_ENABLE
162 process_unicode(keycode, record) &&
165 process_ucis(keycode, record) &&
167 #ifdef PRINTING_ENABLE
168 process_printer(keycode, record) &&
170 #ifdef UNICODEMAP_ENABLE
171 process_unicode_map(keycode, record) &&
177 // Shift / paren setup
181 if (record->event.pressed) {
187 if (record->event.pressed) {
188 print("\nDEBUG: enabled.\n");
193 #ifdef RGBLIGHT_ENABLE
195 if (record->event.pressed) {
201 if (record->event.pressed) {
207 if (record->event.pressed) {
208 rgblight_increase_hue();
213 if (record->event.pressed) {
214 rgblight_decrease_hue();
219 if (record->event.pressed) {
220 rgblight_increase_sat();
225 if (record->event.pressed) {
226 rgblight_decrease_sat();
231 if (record->event.pressed) {
232 rgblight_increase_val();
237 if (record->event.pressed) {
238 rgblight_decrease_val();
243 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
244 if (record->event.pressed) {
245 // MAGIC actions (BOOTMAGIC without the boot)
246 if (!eeconfig_is_enabled()) {
250 keymap_config.raw = eeconfig_read_keymap();
253 case MAGIC_SWAP_CONTROL_CAPSLOCK:
254 keymap_config.swap_control_capslock = true;
256 case MAGIC_CAPSLOCK_TO_CONTROL:
257 keymap_config.capslock_to_control = true;
259 case MAGIC_SWAP_LALT_LGUI:
260 keymap_config.swap_lalt_lgui = true;
262 case MAGIC_SWAP_RALT_RGUI:
263 keymap_config.swap_ralt_rgui = true;
266 keymap_config.no_gui = true;
268 case MAGIC_SWAP_GRAVE_ESC:
269 keymap_config.swap_grave_esc = true;
271 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
272 keymap_config.swap_backslash_backspace = true;
274 case MAGIC_HOST_NKRO:
275 keymap_config.nkro = true;
277 case MAGIC_SWAP_ALT_GUI:
278 keymap_config.swap_lalt_lgui = true;
279 keymap_config.swap_ralt_rgui = true;
281 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
282 keymap_config.swap_control_capslock = false;
284 case MAGIC_UNCAPSLOCK_TO_CONTROL:
285 keymap_config.capslock_to_control = false;
287 case MAGIC_UNSWAP_LALT_LGUI:
288 keymap_config.swap_lalt_lgui = false;
290 case MAGIC_UNSWAP_RALT_RGUI:
291 keymap_config.swap_ralt_rgui = false;
294 keymap_config.no_gui = false;
296 case MAGIC_UNSWAP_GRAVE_ESC:
297 keymap_config.swap_grave_esc = false;
299 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
300 keymap_config.swap_backslash_backspace = false;
302 case MAGIC_UNHOST_NKRO:
303 keymap_config.nkro = false;
305 case MAGIC_UNSWAP_ALT_GUI:
306 keymap_config.swap_lalt_lgui = false;
307 keymap_config.swap_ralt_rgui = false;
309 case MAGIC_TOGGLE_NKRO:
310 keymap_config.nkro = !keymap_config.nkro;
315 eeconfig_update_keymap(keymap_config.raw);
316 clear_keyboard(); // clear to prevent stuck keys
322 if (record->event.pressed) {
323 shift_interrupted[0] = false;
324 scs_timer = timer_read ();
325 register_mods(MOD_BIT(KC_LSFT));
328 #ifdef DISABLE_SPACE_CADET_ROLLOVER
329 if (get_mods() & MOD_BIT(KC_RSFT)) {
330 shift_interrupted[0] = true;
331 shift_interrupted[1] = true;
334 if (!shift_interrupted[0] && timer_elapsed(scs_timer) < TAPPING_TERM) {
335 register_code(LSPO_KEY);
336 unregister_code(LSPO_KEY);
338 unregister_mods(MOD_BIT(KC_LSFT));
345 if (record->event.pressed) {
346 shift_interrupted[1] = false;
347 scs_timer = timer_read ();
348 register_mods(MOD_BIT(KC_RSFT));
351 #ifdef DISABLE_SPACE_CADET_ROLLOVER
352 if (get_mods() & MOD_BIT(KC_LSFT)) {
353 shift_interrupted[0] = true;
354 shift_interrupted[1] = true;
357 if (!shift_interrupted[1] && timer_elapsed(scs_timer) < TAPPING_TERM) {
358 register_code(RSPC_KEY);
359 unregister_code(RSPC_KEY);
361 unregister_mods(MOD_BIT(KC_RSFT));
367 shift_interrupted[0] = true;
368 shift_interrupted[1] = true;
373 return process_action_kb(record);
376 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
377 0, 0, 0, 0, 0, 0, 0, 0,
378 0, 0, 0, 0, 0, 0, 0, 0,
379 0, 0, 0, 0, 0, 0, 0, 0,
380 0, 0, 0, 0, 0, 0, 0, 0,
381 0, 1, 1, 1, 1, 1, 1, 0,
382 1, 1, 1, 1, 0, 0, 0, 0,
383 0, 0, 0, 0, 0, 0, 0, 0,
384 0, 0, 1, 0, 1, 0, 1, 1,
385 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 1, 1, 1, 1, 1, 1, 1,
387 1, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 0, 0, 0, 1, 1,
389 0, 0, 0, 0, 0, 0, 0, 0,
390 0, 0, 0, 0, 0, 0, 0, 0,
391 0, 0, 0, 0, 0, 0, 0, 0,
392 0, 0, 0, 1, 1, 1, 1, 0
395 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
396 0, 0, 0, 0, 0, 0, 0, 0,
397 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
398 0, 0, 0, 0, 0, 0, 0, 0,
399 0, 0, 0, KC_ESC, 0, 0, 0, 0,
400 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
401 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
402 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
403 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
404 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
405 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
406 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
407 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
408 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
409 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
410 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
411 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
414 /* for users whose OSes are set to Colemak */
416 #include "keymap_colemak.h"
418 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
419 0, 0, 0, 0, 0, 0, 0, 0,
420 0, 0, 0, 0, 0, 0, 0, 0,
421 0, 0, 0, 0, 0, 0, 0, 0,
422 0, 0, 0, 0, 0, 0, 0, 0,
423 0, 1, 1, 1, 1, 1, 1, 0,
424 1, 1, 1, 1, 0, 0, 0, 0,
425 0, 0, 0, 0, 0, 0, 0, 0,
426 0, 0, 1, 0, 1, 0, 1, 1,
427 1, 1, 1, 1, 1, 1, 1, 1,
428 1, 1, 1, 1, 1, 1, 1, 1,
429 1, 1, 1, 1, 1, 1, 1, 1,
430 1, 1, 1, 0, 0, 0, 1, 1,
431 0, 0, 0, 0, 0, 0, 0, 0,
432 0, 0, 0, 0, 0, 0, 0, 0,
433 0, 0, 0, 0, 0, 0, 0, 0,
434 0, 0, 0, 1, 1, 1, 1, 0
437 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
438 0, 0, 0, 0, 0, 0, 0, 0,
439 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
440 0, 0, 0, 0, 0, 0, 0, 0,
441 0, 0, 0, KC_ESC, 0, 0, 0, 0,
442 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
443 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
444 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
445 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
446 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
447 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
448 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
449 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
450 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
451 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
452 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
453 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
458 void send_string(const char *str) {
461 uint8_t ascii_code = pgm_read_byte(str);
462 if (!ascii_code) break;
463 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
464 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
465 register_code(KC_LSFT);
466 register_code(keycode);
467 unregister_code(keycode);
468 unregister_code(KC_LSFT);
471 register_code(keycode);
472 unregister_code(keycode);
478 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
479 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
486 void tap_random_base64(void) {
487 #if defined(__AVR_ATmega32U4__)
488 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
490 uint8_t key = rand() % 64;
494 register_code(KC_LSFT);
495 register_code(key + KC_A);
496 unregister_code(key + KC_A);
497 unregister_code(KC_LSFT);
500 register_code(key - 26 + KC_A);
501 unregister_code(key - 26 + KC_A);
505 unregister_code(KC_0);
508 register_code(key - 53 + KC_1);
509 unregister_code(key - 53 + KC_1);
512 register_code(KC_LSFT);
513 register_code(KC_EQL);
514 unregister_code(KC_EQL);
515 unregister_code(KC_LSFT);
518 register_code(KC_SLSH);
519 unregister_code(KC_SLSH);
524 void matrix_init_quantum() {
525 #ifdef BACKLIGHT_ENABLE
526 backlight_init_ports();
531 void matrix_scan_quantum() {
536 #ifdef TAP_DANCE_ENABLE
537 matrix_scan_tap_dance();
542 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
544 static const uint8_t backlight_pin = BACKLIGHT_PIN;
546 #if BACKLIGHT_PIN == B7
547 # define COM1x1 COM1C1
549 #elif BACKLIGHT_PIN == B6
550 # define COM1x1 COM1B1
552 #elif BACKLIGHT_PIN == B5
553 # define COM1x1 COM1A1
556 # error "Backlight pin not supported - use B5, B6, or B7"
559 __attribute__ ((weak))
560 void backlight_init_ports(void)
563 // Setup backlight pin as output and output low.
565 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
567 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
569 // Use full 16-bit resolution.
572 // I could write a wall of text here to explain... but TL;DW
573 // Go read the ATmega32u4 datasheet.
574 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
576 // Pin PB7 = OCR1C (Timer 1, Channel C)
577 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
578 // (i.e. start high, go low when counter matches.)
579 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
580 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
582 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
583 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
586 #ifdef BACKLIGHT_BREATHING
587 breathing_defaults();
591 __attribute__ ((weak))
592 void backlight_set(uint8_t level)
594 // Prevent backlight blink on lowest level
596 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
599 // Turn off PWM control on backlight pin, revert to output low.
600 TCCR1A &= ~(_BV(COM1x1));
602 } else if ( level == BACKLIGHT_LEVELS ) {
603 // Turn on PWM control of backlight pin
604 TCCR1A |= _BV(COM1x1);
605 // Set the brightness
608 // Turn on PWM control of backlight pin
609 TCCR1A |= _BV(COM1x1);
610 // Set the brightness
611 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
614 #ifdef BACKLIGHT_BREATHING
615 breathing_intensity_default();
620 #ifdef BACKLIGHT_BREATHING
622 #define BREATHING_NO_HALT 0
623 #define BREATHING_HALT_OFF 1
624 #define BREATHING_HALT_ON 2
626 static uint8_t breath_intensity;
627 static uint8_t breath_speed;
628 static uint16_t breathing_index;
629 static uint8_t breathing_halt;
631 void breathing_enable(void)
633 if (get_backlight_level() == 0)
639 // Set breathing_index to be at the midpoint (brightest point)
640 breathing_index = 0x20 << breath_speed;
643 breathing_halt = BREATHING_NO_HALT;
645 // Enable breathing interrupt
646 TIMSK1 |= _BV(OCIE1A);
649 void breathing_pulse(void)
651 if (get_backlight_level() == 0)
657 // Set breathing_index to be at the midpoint + 1 (brightest point)
658 breathing_index = 0x21 << breath_speed;
661 breathing_halt = BREATHING_HALT_ON;
663 // Enable breathing interrupt
664 TIMSK1 |= _BV(OCIE1A);
667 void breathing_disable(void)
669 // Disable breathing interrupt
670 TIMSK1 &= ~_BV(OCIE1A);
671 backlight_set(get_backlight_level());
674 void breathing_self_disable(void)
676 if (get_backlight_level() == 0)
678 breathing_halt = BREATHING_HALT_OFF;
682 breathing_halt = BREATHING_HALT_ON;
685 //backlight_set(get_backlight_level());
688 void breathing_toggle(void)
692 if (get_backlight_level() == 0)
698 // Set breathing_index to be at the midpoint + 1 (brightest point)
699 breathing_index = 0x21 << breath_speed;
702 breathing_halt = BREATHING_NO_HALT;
705 // Toggle breathing interrupt
706 TIMSK1 ^= _BV(OCIE1A);
708 // Restore backlight level
711 backlight_set(get_backlight_level());
715 bool is_breathing(void)
717 return (TIMSK1 && _BV(OCIE1A));
720 void breathing_intensity_default(void)
722 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
723 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
726 void breathing_intensity_set(uint8_t value)
728 breath_intensity = value;
731 void breathing_speed_default(void)
736 void breathing_speed_set(uint8_t value)
738 bool is_breathing_now = is_breathing();
739 uint8_t old_breath_speed = breath_speed;
741 if (is_breathing_now)
743 // Disable breathing interrupt
744 TIMSK1 &= ~_BV(OCIE1A);
747 breath_speed = value;
749 if (is_breathing_now)
751 // Adjust index to account for new speed
752 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
754 // Enable breathing interrupt
755 TIMSK1 |= _BV(OCIE1A);
760 void breathing_speed_inc(uint8_t value)
762 if ((uint16_t)(breath_speed - value) > 10 )
764 breathing_speed_set(0);
768 breathing_speed_set(breath_speed - value);
772 void breathing_speed_dec(uint8_t value)
774 if ((uint16_t)(breath_speed + value) > 10 )
776 breathing_speed_set(10);
780 breathing_speed_set(breath_speed + value);
784 void breathing_defaults(void)
786 breathing_intensity_default();
787 breathing_speed_default();
788 breathing_halt = BREATHING_NO_HALT;
791 /* Breathing Sleep LED brighness(PWM On period) table
792 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
794 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
795 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
797 static const uint8_t breathing_table[64] PROGMEM = {
798 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
799 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
800 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
801 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
804 ISR(TIMER1_COMPA_vect)
806 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
809 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
811 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
813 // Disable breathing interrupt
814 TIMSK1 &= ~_BV(OCIE1A);
817 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
827 __attribute__ ((weak))
828 void backlight_init_ports(void)
833 __attribute__ ((weak))
834 void backlight_set(uint8_t level)
842 // Functions for spitting out values
845 void send_dword(uint32_t number) { // this might not actually work
846 uint16_t word = (number >> 16);
848 send_word(number & 0xFFFFUL);
851 void send_word(uint16_t number) {
852 uint8_t byte = number >> 8;
854 send_byte(number & 0xFF);
857 void send_byte(uint8_t number) {
858 uint8_t nibble = number >> 4;
860 send_nibble(number & 0xF);
863 void send_nibble(uint8_t number) {
867 unregister_code(KC_0);
870 register_code(KC_1 + (number - 1));
871 unregister_code(KC_1 + (number - 1));
874 register_code(KC_A + (number - 0xA));
875 unregister_code(KC_A + (number - 0xA));
880 void api_send_unicode(uint32_t unicode) {
883 dword_to_bytes(unicode, chunk);
884 MT_SEND_DATA(DT_UNICODE, chunk, 5);
888 __attribute__ ((weak))
889 void led_set_user(uint8_t usb_led) {
893 __attribute__ ((weak))
894 void led_set_kb(uint8_t usb_led) {
895 led_set_user(usb_led);
898 __attribute__ ((weak))
899 void led_init_ports(void)
904 __attribute__ ((weak))
905 void led_set(uint8_t usb_led)
910 // // Using PE6 Caps Lock LED
911 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
928 //------------------------------------------------------------------------------
929 // Override these functions in your keymap file to play different tunes on
930 // different events such as startup and bootloader jump
932 __attribute__ ((weak))
933 void startup_user() {}
935 __attribute__ ((weak))
936 void shutdown_user() {}
938 //------------------------------------------------------------------------------