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 void register_code16 (uint16_t code) {
37 do_code16 (code, register_code);
41 void unregister_code16 (uint16_t code) {
42 unregister_code (code);
43 do_code16 (code, unregister_code);
46 __attribute__ ((weak))
47 bool process_action_kb(keyrecord_t *record) {
51 __attribute__ ((weak))
52 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
53 return process_record_user(keycode, record);
56 __attribute__ ((weak))
57 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
61 void reset_keyboard(void) {
68 #ifdef CATERINA_BOOTLOADER
69 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
74 // Shift / paren setup
83 static bool shift_interrupted[2] = {0, 0};
84 static uint16_t scs_timer = 0;
86 bool process_record_quantum(keyrecord_t *record) {
88 /* This gets the keycode from the key pressed */
89 keypos_t key = record->event.key;
92 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
93 /* TODO: Use store_or_get_action() or a similar function. */
94 if (!disable_action_cache) {
97 if (record->event.pressed) {
98 layer = layer_switch_get_layer(key);
99 update_source_layers_cache(key, layer);
101 layer = read_source_layers_cache(key);
103 keycode = keymap_key_to_keycode(layer, key);
106 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
108 // This is how you use actions here
109 // if (keycode == KC_LEAD) {
111 // action.code = ACTION_DEFAULT_LAYER_SET(0);
112 // process_action(record, action);
117 process_record_kb(keycode, record) &&
119 process_midi(keycode, record) &&
122 process_music(keycode, record) &&
124 #ifdef TAP_DANCE_ENABLE
125 process_tap_dance(keycode, record) &&
127 #ifndef DISABLE_LEADER
128 process_leader(keycode, record) &&
130 #ifndef DISABLE_CHORDING
131 process_chording(keycode, record) &&
133 #ifdef UNICODE_ENABLE
134 process_unicode(keycode, record) &&
137 process_ucis(keycode, record) &&
139 #ifdef PRINTING_ENABLE
140 process_printer(keycode, record) &&
142 #ifdef UNICODEMAP_ENABLE
143 process_unicode_map(keycode, record) &&
149 // Shift / paren setup
153 if (record->event.pressed) {
159 if (record->event.pressed) {
160 print("\nDEBUG: enabled.\n");
165 #ifdef RGBLIGHT_ENABLE
167 if (record->event.pressed) {
173 if (record->event.pressed) {
179 if (record->event.pressed) {
180 rgblight_increase_hue();
185 if (record->event.pressed) {
186 rgblight_decrease_hue();
191 if (record->event.pressed) {
192 rgblight_increase_sat();
197 if (record->event.pressed) {
198 rgblight_decrease_sat();
203 if (record->event.pressed) {
204 rgblight_increase_val();
209 if (record->event.pressed) {
210 rgblight_decrease_val();
215 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
216 if (record->event.pressed) {
217 // MAGIC actions (BOOTMAGIC without the boot)
218 if (!eeconfig_is_enabled()) {
222 keymap_config.raw = eeconfig_read_keymap();
225 case MAGIC_SWAP_CONTROL_CAPSLOCK:
226 keymap_config.swap_control_capslock = true;
228 case MAGIC_CAPSLOCK_TO_CONTROL:
229 keymap_config.capslock_to_control = true;
231 case MAGIC_SWAP_LALT_LGUI:
232 keymap_config.swap_lalt_lgui = true;
234 case MAGIC_SWAP_RALT_RGUI:
235 keymap_config.swap_ralt_rgui = true;
238 keymap_config.no_gui = true;
240 case MAGIC_SWAP_GRAVE_ESC:
241 keymap_config.swap_grave_esc = true;
243 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
244 keymap_config.swap_backslash_backspace = true;
246 case MAGIC_HOST_NKRO:
247 keymap_config.nkro = true;
249 case MAGIC_SWAP_ALT_GUI:
250 keymap_config.swap_lalt_lgui = true;
251 keymap_config.swap_ralt_rgui = true;
253 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
254 keymap_config.swap_control_capslock = false;
256 case MAGIC_UNCAPSLOCK_TO_CONTROL:
257 keymap_config.capslock_to_control = false;
259 case MAGIC_UNSWAP_LALT_LGUI:
260 keymap_config.swap_lalt_lgui = false;
262 case MAGIC_UNSWAP_RALT_RGUI:
263 keymap_config.swap_ralt_rgui = false;
266 keymap_config.no_gui = false;
268 case MAGIC_UNSWAP_GRAVE_ESC:
269 keymap_config.swap_grave_esc = false;
271 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
272 keymap_config.swap_backslash_backspace = false;
274 case MAGIC_UNHOST_NKRO:
275 keymap_config.nkro = false;
277 case MAGIC_UNSWAP_ALT_GUI:
278 keymap_config.swap_lalt_lgui = false;
279 keymap_config.swap_ralt_rgui = false;
281 case MAGIC_TOGGLE_NKRO:
282 keymap_config.nkro = !keymap_config.nkro;
287 eeconfig_update_keymap(keymap_config.raw);
288 clear_keyboard(); // clear to prevent stuck keys
294 if (record->event.pressed) {
295 shift_interrupted[0] = false;
296 scs_timer = timer_read ();
297 register_mods(MOD_BIT(KC_LSFT));
300 #ifdef DISABLE_SPACE_CADET_ROLLOVER
301 if (get_mods() & MOD_BIT(KC_RSFT)) {
302 shift_interrupted[0] = true;
303 shift_interrupted[1] = true;
306 if (!shift_interrupted[0] && timer_elapsed(scs_timer) < TAPPING_TERM) {
307 register_code(LSPO_KEY);
308 unregister_code(LSPO_KEY);
310 unregister_mods(MOD_BIT(KC_LSFT));
317 if (record->event.pressed) {
318 shift_interrupted[1] = false;
319 scs_timer = timer_read ();
320 register_mods(MOD_BIT(KC_RSFT));
323 #ifdef DISABLE_SPACE_CADET_ROLLOVER
324 if (get_mods() & MOD_BIT(KC_LSFT)) {
325 shift_interrupted[0] = true;
326 shift_interrupted[1] = true;
329 if (!shift_interrupted[1] && timer_elapsed(scs_timer) < TAPPING_TERM) {
330 register_code(RSPC_KEY);
331 unregister_code(RSPC_KEY);
333 unregister_mods(MOD_BIT(KC_RSFT));
339 shift_interrupted[0] = true;
340 shift_interrupted[1] = true;
345 return process_action_kb(record);
348 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
349 0, 0, 0, 0, 0, 0, 0, 0,
350 0, 0, 0, 0, 0, 0, 0, 0,
351 0, 0, 0, 0, 0, 0, 0, 0,
352 0, 0, 0, 0, 0, 0, 0, 0,
353 0, 1, 1, 1, 1, 1, 1, 0,
354 1, 1, 1, 1, 0, 0, 0, 0,
355 0, 0, 0, 0, 0, 0, 0, 0,
356 0, 0, 1, 0, 1, 0, 1, 1,
357 1, 1, 1, 1, 1, 1, 1, 1,
358 1, 1, 1, 1, 1, 1, 1, 1,
359 1, 1, 1, 1, 1, 1, 1, 1,
360 1, 1, 1, 0, 0, 0, 1, 1,
361 0, 0, 0, 0, 0, 0, 0, 0,
362 0, 0, 0, 0, 0, 0, 0, 0,
363 0, 0, 0, 0, 0, 0, 0, 0,
364 0, 0, 0, 1, 1, 1, 1, 0
367 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
368 0, 0, 0, 0, 0, 0, 0, 0,
369 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
370 0, 0, 0, 0, 0, 0, 0, 0,
371 0, 0, 0, KC_ESC, 0, 0, 0, 0,
372 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
373 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
374 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
375 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
376 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
377 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
378 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
379 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
380 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
381 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
382 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
383 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
386 /* for users whose OSes are set to Colemak */
388 #include "keymap_colemak.h"
390 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
391 0, 0, 0, 0, 0, 0, 0, 0,
392 0, 0, 0, 0, 0, 0, 0, 0,
393 0, 0, 0, 0, 0, 0, 0, 0,
394 0, 0, 0, 0, 0, 0, 0, 0,
395 0, 1, 1, 1, 1, 1, 1, 0,
396 1, 1, 1, 1, 0, 0, 0, 0,
397 0, 0, 0, 0, 0, 0, 0, 0,
398 0, 0, 1, 0, 1, 0, 1, 1,
399 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 0, 0, 0, 1, 1,
403 0, 0, 0, 0, 0, 0, 0, 0,
404 0, 0, 0, 0, 0, 0, 0, 0,
405 0, 0, 0, 0, 0, 0, 0, 0,
406 0, 0, 0, 1, 1, 1, 1, 0
409 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
410 0, 0, 0, 0, 0, 0, 0, 0,
411 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
412 0, 0, 0, 0, 0, 0, 0, 0,
413 0, 0, 0, KC_ESC, 0, 0, 0, 0,
414 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
415 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
416 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
417 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
418 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
419 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
420 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
421 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
422 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
423 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
424 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
425 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
430 void send_string(const char *str) {
433 uint8_t ascii_code = pgm_read_byte(str);
434 if (!ascii_code) break;
435 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
436 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
437 register_code(KC_LSFT);
438 register_code(keycode);
439 unregister_code(keycode);
440 unregister_code(KC_LSFT);
443 register_code(keycode);
444 unregister_code(keycode);
450 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
451 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
458 void tap_random_base64(void) {
459 #if defined(__AVR_ATmega32U4__)
460 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
462 uint8_t key = rand() % 64;
466 register_code(KC_LSFT);
467 register_code(key + KC_A);
468 unregister_code(key + KC_A);
469 unregister_code(KC_LSFT);
472 register_code(key - 26 + KC_A);
473 unregister_code(key - 26 + KC_A);
477 unregister_code(KC_0);
480 register_code(key - 53 + KC_1);
481 unregister_code(key - 53 + KC_1);
484 register_code(KC_LSFT);
485 register_code(KC_EQL);
486 unregister_code(KC_EQL);
487 unregister_code(KC_LSFT);
490 register_code(KC_SLSH);
491 unregister_code(KC_SLSH);
496 void matrix_init_quantum() {
497 #ifdef BACKLIGHT_ENABLE
498 backlight_init_ports();
503 void matrix_scan_quantum() {
508 #ifdef TAP_DANCE_ENABLE
509 matrix_scan_tap_dance();
514 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
516 static const uint8_t backlight_pin = BACKLIGHT_PIN;
518 #if BACKLIGHT_PIN == B7
519 # define COM1x1 COM1C1
521 #elif BACKLIGHT_PIN == B6
522 # define COM1x1 COM1B1
524 #elif BACKLIGHT_PIN == B5
525 # define COM1x1 COM1A1
528 # error "Backlight pin not supported - use B5, B6, or B7"
531 __attribute__ ((weak))
532 void backlight_init_ports(void)
535 // Setup backlight pin as output and output low.
537 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
539 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
541 // Use full 16-bit resolution.
544 // I could write a wall of text here to explain... but TL;DW
545 // Go read the ATmega32u4 datasheet.
546 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
548 // Pin PB7 = OCR1C (Timer 1, Channel C)
549 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
550 // (i.e. start high, go low when counter matches.)
551 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
552 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
554 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
555 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
558 #ifdef BACKLIGHT_BREATHING
559 breathing_defaults();
563 __attribute__ ((weak))
564 void backlight_set(uint8_t level)
566 // Prevent backlight blink on lowest level
568 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
571 // Turn off PWM control on backlight pin, revert to output low.
572 TCCR1A &= ~(_BV(COM1x1));
574 } else if ( level == BACKLIGHT_LEVELS ) {
575 // Turn on PWM control of backlight pin
576 TCCR1A |= _BV(COM1x1);
577 // Set the brightness
580 // Turn on PWM control of backlight pin
581 TCCR1A |= _BV(COM1x1);
582 // Set the brightness
583 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
586 #ifdef BACKLIGHT_BREATHING
587 breathing_intensity_default();
592 #ifdef BACKLIGHT_BREATHING
594 #define BREATHING_NO_HALT 0
595 #define BREATHING_HALT_OFF 1
596 #define BREATHING_HALT_ON 2
598 static uint8_t breath_intensity;
599 static uint8_t breath_speed;
600 static uint16_t breathing_index;
601 static uint8_t breathing_halt;
603 void breathing_enable(void)
605 if (get_backlight_level() == 0)
611 // Set breathing_index to be at the midpoint (brightest point)
612 breathing_index = 0x20 << breath_speed;
615 breathing_halt = BREATHING_NO_HALT;
617 // Enable breathing interrupt
618 TIMSK1 |= _BV(OCIE1A);
621 void breathing_pulse(void)
623 if (get_backlight_level() == 0)
629 // Set breathing_index to be at the midpoint + 1 (brightest point)
630 breathing_index = 0x21 << breath_speed;
633 breathing_halt = BREATHING_HALT_ON;
635 // Enable breathing interrupt
636 TIMSK1 |= _BV(OCIE1A);
639 void breathing_disable(void)
641 // Disable breathing interrupt
642 TIMSK1 &= ~_BV(OCIE1A);
643 backlight_set(get_backlight_level());
646 void breathing_self_disable(void)
648 if (get_backlight_level() == 0)
650 breathing_halt = BREATHING_HALT_OFF;
654 breathing_halt = BREATHING_HALT_ON;
657 //backlight_set(get_backlight_level());
660 void breathing_toggle(void)
664 if (get_backlight_level() == 0)
670 // Set breathing_index to be at the midpoint + 1 (brightest point)
671 breathing_index = 0x21 << breath_speed;
674 breathing_halt = BREATHING_NO_HALT;
677 // Toggle breathing interrupt
678 TIMSK1 ^= _BV(OCIE1A);
680 // Restore backlight level
683 backlight_set(get_backlight_level());
687 bool is_breathing(void)
689 return (TIMSK1 && _BV(OCIE1A));
692 void breathing_intensity_default(void)
694 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
695 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
698 void breathing_intensity_set(uint8_t value)
700 breath_intensity = value;
703 void breathing_speed_default(void)
708 void breathing_speed_set(uint8_t value)
710 bool is_breathing_now = is_breathing();
711 uint8_t old_breath_speed = breath_speed;
713 if (is_breathing_now)
715 // Disable breathing interrupt
716 TIMSK1 &= ~_BV(OCIE1A);
719 breath_speed = value;
721 if (is_breathing_now)
723 // Adjust index to account for new speed
724 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
726 // Enable breathing interrupt
727 TIMSK1 |= _BV(OCIE1A);
732 void breathing_speed_inc(uint8_t value)
734 if ((uint16_t)(breath_speed - value) > 10 )
736 breathing_speed_set(0);
740 breathing_speed_set(breath_speed - value);
744 void breathing_speed_dec(uint8_t value)
746 if ((uint16_t)(breath_speed + value) > 10 )
748 breathing_speed_set(10);
752 breathing_speed_set(breath_speed + value);
756 void breathing_defaults(void)
758 breathing_intensity_default();
759 breathing_speed_default();
760 breathing_halt = BREATHING_NO_HALT;
763 /* Breathing Sleep LED brighness(PWM On period) table
764 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
766 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
767 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
769 static const uint8_t breathing_table[64] PROGMEM = {
770 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
771 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
772 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
773 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
776 ISR(TIMER1_COMPA_vect)
778 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
781 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
783 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
785 // Disable breathing interrupt
786 TIMSK1 &= ~_BV(OCIE1A);
789 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
799 __attribute__ ((weak))
800 void backlight_init_ports(void)
805 __attribute__ ((weak))
806 void backlight_set(uint8_t level)
814 // Functions for spitting out values
817 void send_dword(uint32_t number) { // this might not actually work
818 uint16_t word = (number >> 16);
820 send_word(number & 0xFFFFUL);
823 void send_word(uint16_t number) {
824 uint8_t byte = number >> 8;
826 send_byte(number & 0xFF);
829 void send_byte(uint8_t number) {
830 uint8_t nibble = number >> 4;
832 send_nibble(number & 0xF);
835 void send_nibble(uint8_t number) {
839 unregister_code(KC_0);
842 register_code(KC_1 + (number - 1));
843 unregister_code(KC_1 + (number - 1));
846 register_code(KC_A + (number - 0xA));
847 unregister_code(KC_A + (number - 0xA));
852 void api_send_unicode(uint32_t unicode) {
855 dword_to_bytes(unicode, chunk);
856 MT_SEND_DATA(DT_UNICODE, chunk, 5);
860 __attribute__ ((weak))
861 void led_set_user(uint8_t usb_led) {
865 __attribute__ ((weak))
866 void led_set_kb(uint8_t usb_led) {
867 led_set_user(usb_led);
870 __attribute__ ((weak))
871 void led_init_ports(void)
876 __attribute__ ((weak))
877 void led_set(uint8_t usb_led)
882 // // Using PE6 Caps Lock LED
883 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
900 //------------------------------------------------------------------------------
901 // Override these functions in your keymap file to play different tunes on
902 // different events such as startup and bootloader jump
904 __attribute__ ((weak))
905 void startup_user() {}
907 __attribute__ ((weak))
908 void shutdown_user() {}
910 //------------------------------------------------------------------------------