4 #define TAPPING_TERM 200
7 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
9 case QK_MODS ... QK_MODS_MAX:
34 void register_code16 (uint16_t code) {
35 do_code16 (code, register_code);
39 void unregister_code16 (uint16_t code) {
40 unregister_code (code);
41 do_code16 (code, unregister_code);
44 __attribute__ ((weak))
45 bool process_action_kb(keyrecord_t *record) {
49 __attribute__ ((weak))
50 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
51 return process_record_user(keycode, record);
54 __attribute__ ((weak))
55 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
59 void reset_keyboard(void) {
66 #ifdef CATERINA_BOOTLOADER
67 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
72 // Shift / paren setup
81 static bool shift_interrupted[2] = {0, 0};
82 static uint16_t scs_timer = 0;
84 bool process_record_quantum(keyrecord_t *record) {
86 /* This gets the keycode from the key pressed */
87 keypos_t key = record->event.key;
90 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
91 /* TODO: Use store_or_get_action() or a similar function. */
92 if (!disable_action_cache) {
95 if (record->event.pressed) {
96 layer = layer_switch_get_layer(key);
97 update_source_layers_cache(key, layer);
99 layer = read_source_layers_cache(key);
101 keycode = keymap_key_to_keycode(layer, key);
104 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
106 // This is how you use actions here
107 // if (keycode == KC_LEAD) {
109 // action.code = ACTION_DEFAULT_LAYER_SET(0);
110 // process_action(record, action);
115 process_record_kb(keycode, record) &&
117 process_midi(keycode, record) &&
120 process_music(keycode, record) &&
122 #ifdef TAP_DANCE_ENABLE
123 process_tap_dance(keycode, record) &&
125 #ifndef DISABLE_LEADER
126 process_leader(keycode, record) &&
128 #ifndef DISABLE_CHORDING
129 process_chording(keycode, record) &&
131 #ifdef UNICODE_ENABLE
132 process_unicode(keycode, record) &&
135 process_ucis(keycode, record) &&
137 #ifdef PRINTING_ENABLE
138 process_printer(keycode, record) &&
140 #ifdef UNICODEMAP_ENABLE
141 process_unicode_map(keycode, record) &&
147 // Shift / paren setup
151 if (record->event.pressed) {
157 if (record->event.pressed) {
158 print("\nDEBUG: enabled.\n");
163 #ifdef RGBLIGHT_ENABLE
165 if (record->event.pressed) {
171 if (record->event.pressed) {
177 if (record->event.pressed) {
178 rgblight_increase_hue();
183 if (record->event.pressed) {
184 rgblight_decrease_hue();
189 if (record->event.pressed) {
190 rgblight_increase_sat();
195 if (record->event.pressed) {
196 rgblight_decrease_sat();
201 if (record->event.pressed) {
202 rgblight_increase_val();
207 if (record->event.pressed) {
208 rgblight_decrease_val();
213 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
214 if (record->event.pressed) {
215 // MAGIC actions (BOOTMAGIC without the boot)
216 if (!eeconfig_is_enabled()) {
220 keymap_config.raw = eeconfig_read_keymap();
223 case MAGIC_SWAP_CONTROL_CAPSLOCK:
224 keymap_config.swap_control_capslock = true;
226 case MAGIC_CAPSLOCK_TO_CONTROL:
227 keymap_config.capslock_to_control = true;
229 case MAGIC_SWAP_LALT_LGUI:
230 keymap_config.swap_lalt_lgui = true;
232 case MAGIC_SWAP_RALT_RGUI:
233 keymap_config.swap_ralt_rgui = true;
236 keymap_config.no_gui = true;
238 case MAGIC_SWAP_GRAVE_ESC:
239 keymap_config.swap_grave_esc = true;
241 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
242 keymap_config.swap_backslash_backspace = true;
244 case MAGIC_HOST_NKRO:
245 keymap_config.nkro = true;
247 case MAGIC_SWAP_ALT_GUI:
248 keymap_config.swap_lalt_lgui = true;
249 keymap_config.swap_ralt_rgui = true;
251 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
252 keymap_config.swap_control_capslock = false;
254 case MAGIC_UNCAPSLOCK_TO_CONTROL:
255 keymap_config.capslock_to_control = false;
257 case MAGIC_UNSWAP_LALT_LGUI:
258 keymap_config.swap_lalt_lgui = false;
260 case MAGIC_UNSWAP_RALT_RGUI:
261 keymap_config.swap_ralt_rgui = false;
264 keymap_config.no_gui = false;
266 case MAGIC_UNSWAP_GRAVE_ESC:
267 keymap_config.swap_grave_esc = false;
269 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
270 keymap_config.swap_backslash_backspace = false;
272 case MAGIC_UNHOST_NKRO:
273 keymap_config.nkro = false;
275 case MAGIC_UNSWAP_ALT_GUI:
276 keymap_config.swap_lalt_lgui = false;
277 keymap_config.swap_ralt_rgui = false;
279 case MAGIC_TOGGLE_NKRO:
280 keymap_config.nkro = !keymap_config.nkro;
285 eeconfig_update_keymap(keymap_config.raw);
286 clear_keyboard(); // clear to prevent stuck keys
292 if (record->event.pressed) {
293 shift_interrupted[0] = false;
294 scs_timer = timer_read ();
295 register_mods(MOD_BIT(KC_LSFT));
298 #ifdef DISABLE_SPACE_CADET_ROLLOVER
299 if (get_mods() & MOD_BIT(KC_RSFT)) {
300 shift_interrupted[0] = true;
301 shift_interrupted[1] = true;
304 if (!shift_interrupted[0] && timer_elapsed(scs_timer) < TAPPING_TERM) {
305 register_code(LSPO_KEY);
306 unregister_code(LSPO_KEY);
308 unregister_mods(MOD_BIT(KC_LSFT));
315 if (record->event.pressed) {
316 shift_interrupted[1] = false;
317 scs_timer = timer_read ();
318 register_mods(MOD_BIT(KC_RSFT));
321 #ifdef DISABLE_SPACE_CADET_ROLLOVER
322 if (get_mods() & MOD_BIT(KC_LSFT)) {
323 shift_interrupted[0] = true;
324 shift_interrupted[1] = true;
327 if (!shift_interrupted[1] && timer_elapsed(scs_timer) < TAPPING_TERM) {
328 register_code(RSPC_KEY);
329 unregister_code(RSPC_KEY);
331 unregister_mods(MOD_BIT(KC_RSFT));
337 shift_interrupted[0] = true;
338 shift_interrupted[1] = true;
343 return process_action_kb(record);
346 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
347 0, 0, 0, 0, 0, 0, 0, 0,
348 0, 0, 0, 0, 0, 0, 0, 0,
349 0, 0, 0, 0, 0, 0, 0, 0,
350 0, 0, 0, 0, 0, 0, 0, 0,
351 0, 1, 1, 1, 1, 1, 1, 0,
352 1, 1, 1, 1, 0, 0, 0, 0,
353 0, 0, 0, 0, 0, 0, 0, 0,
354 0, 0, 1, 0, 1, 0, 1, 1,
355 1, 1, 1, 1, 1, 1, 1, 1,
356 1, 1, 1, 1, 1, 1, 1, 1,
357 1, 1, 1, 1, 1, 1, 1, 1,
358 1, 1, 1, 0, 0, 0, 1, 1,
359 0, 0, 0, 0, 0, 0, 0, 0,
360 0, 0, 0, 0, 0, 0, 0, 0,
361 0, 0, 0, 0, 0, 0, 0, 0,
362 0, 0, 0, 1, 1, 1, 1, 0
365 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
366 0, 0, 0, 0, 0, 0, 0, 0,
367 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
368 0, 0, 0, 0, 0, 0, 0, 0,
369 0, 0, 0, KC_ESC, 0, 0, 0, 0,
370 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
371 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
372 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
373 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
374 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
375 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
376 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
377 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
378 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
379 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
380 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
381 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
384 /* for users whose OSes are set to Colemak */
386 #include "keymap_colemak.h"
388 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
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, 0, 0, 0, 0, 0,
393 0, 1, 1, 1, 1, 1, 1, 0,
394 1, 1, 1, 1, 0, 0, 0, 0,
395 0, 0, 0, 0, 0, 0, 0, 0,
396 0, 0, 1, 0, 1, 0, 1, 1,
397 1, 1, 1, 1, 1, 1, 1, 1,
398 1, 1, 1, 1, 1, 1, 1, 1,
399 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 0, 0, 0, 1, 1,
401 0, 0, 0, 0, 0, 0, 0, 0,
402 0, 0, 0, 0, 0, 0, 0, 0,
403 0, 0, 0, 0, 0, 0, 0, 0,
404 0, 0, 0, 1, 1, 1, 1, 0
407 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
408 0, 0, 0, 0, 0, 0, 0, 0,
409 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
410 0, 0, 0, 0, 0, 0, 0, 0,
411 0, 0, 0, KC_ESC, 0, 0, 0, 0,
412 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
413 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
414 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
415 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
416 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
417 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
418 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
419 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
420 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
421 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
422 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
423 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
428 void send_string(const char *str) {
431 uint8_t ascii_code = pgm_read_byte(str);
432 if (!ascii_code) break;
433 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
434 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
435 register_code(KC_LSFT);
436 register_code(keycode);
437 unregister_code(keycode);
438 unregister_code(KC_LSFT);
441 register_code(keycode);
442 unregister_code(keycode);
448 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
449 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
456 void tap_random_base64(void) {
457 #if defined(__AVR_ATmega32U4__)
458 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
460 uint8_t key = rand() % 64;
464 register_code(KC_LSFT);
465 register_code(key + KC_A);
466 unregister_code(key + KC_A);
467 unregister_code(KC_LSFT);
470 register_code(key - 26 + KC_A);
471 unregister_code(key - 26 + KC_A);
475 unregister_code(KC_0);
478 register_code(key - 53 + KC_1);
479 unregister_code(key - 53 + KC_1);
482 register_code(KC_LSFT);
483 register_code(KC_EQL);
484 unregister_code(KC_EQL);
485 unregister_code(KC_LSFT);
488 register_code(KC_SLSH);
489 unregister_code(KC_SLSH);
494 void matrix_init_quantum() {
495 #ifdef BACKLIGHT_ENABLE
496 backlight_init_ports();
501 void matrix_scan_quantum() {
506 #ifdef TAP_DANCE_ENABLE
507 matrix_scan_tap_dance();
512 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
514 static const uint8_t backlight_pin = BACKLIGHT_PIN;
516 #if BACKLIGHT_PIN == B7
517 # define COM1x1 COM1C1
519 #elif BACKLIGHT_PIN == B6
520 # define COM1x1 COM1B1
522 #elif BACKLIGHT_PIN == B5
523 # define COM1x1 COM1A1
526 # error "Backlight pin not supported - use B5, B6, or B7"
529 __attribute__ ((weak))
530 void backlight_init_ports(void)
533 // Setup backlight pin as output and output low.
535 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
537 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
539 // Use full 16-bit resolution.
542 // I could write a wall of text here to explain... but TL;DW
543 // Go read the ATmega32u4 datasheet.
544 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
546 // Pin PB7 = OCR1C (Timer 1, Channel C)
547 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
548 // (i.e. start high, go low when counter matches.)
549 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
550 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
552 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
553 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
556 #ifdef BACKLIGHT_BREATHING
557 breathing_defaults();
561 __attribute__ ((weak))
562 void backlight_set(uint8_t level)
564 // Prevent backlight blink on lowest level
566 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
569 // Turn off PWM control on backlight pin, revert to output low.
570 TCCR1A &= ~(_BV(COM1x1));
572 } else if ( level == BACKLIGHT_LEVELS ) {
573 // Turn on PWM control of backlight pin
574 TCCR1A |= _BV(COM1x1);
575 // Set the brightness
578 // Turn on PWM control of backlight pin
579 TCCR1A |= _BV(COM1x1);
580 // Set the brightness
581 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
584 #ifdef BACKLIGHT_BREATHING
585 breathing_intensity_default();
590 #ifdef BACKLIGHT_BREATHING
592 #define BREATHING_NO_HALT 0
593 #define BREATHING_HALT_OFF 1
594 #define BREATHING_HALT_ON 2
596 static uint8_t breath_intensity;
597 static uint8_t breath_speed;
598 static uint16_t breathing_index;
599 static uint8_t breathing_halt;
601 void breathing_enable(void)
603 if (get_backlight_level() == 0)
609 // Set breathing_index to be at the midpoint (brightest point)
610 breathing_index = 0x20 << breath_speed;
613 breathing_halt = BREATHING_NO_HALT;
615 // Enable breathing interrupt
616 TIMSK1 |= _BV(OCIE1A);
619 void breathing_pulse(void)
621 if (get_backlight_level() == 0)
627 // Set breathing_index to be at the midpoint + 1 (brightest point)
628 breathing_index = 0x21 << breath_speed;
631 breathing_halt = BREATHING_HALT_ON;
633 // Enable breathing interrupt
634 TIMSK1 |= _BV(OCIE1A);
637 void breathing_disable(void)
639 // Disable breathing interrupt
640 TIMSK1 &= ~_BV(OCIE1A);
641 backlight_set(get_backlight_level());
644 void breathing_self_disable(void)
646 if (get_backlight_level() == 0)
648 breathing_halt = BREATHING_HALT_OFF;
652 breathing_halt = BREATHING_HALT_ON;
655 //backlight_set(get_backlight_level());
658 void breathing_toggle(void)
662 if (get_backlight_level() == 0)
668 // Set breathing_index to be at the midpoint + 1 (brightest point)
669 breathing_index = 0x21 << breath_speed;
672 breathing_halt = BREATHING_NO_HALT;
675 // Toggle breathing interrupt
676 TIMSK1 ^= _BV(OCIE1A);
678 // Restore backlight level
681 backlight_set(get_backlight_level());
685 bool is_breathing(void)
687 return (TIMSK1 && _BV(OCIE1A));
690 void breathing_intensity_default(void)
692 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
693 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
696 void breathing_intensity_set(uint8_t value)
698 breath_intensity = value;
701 void breathing_speed_default(void)
706 void breathing_speed_set(uint8_t value)
708 bool is_breathing_now = is_breathing();
709 uint8_t old_breath_speed = breath_speed;
711 if (is_breathing_now)
713 // Disable breathing interrupt
714 TIMSK1 &= ~_BV(OCIE1A);
717 breath_speed = value;
719 if (is_breathing_now)
721 // Adjust index to account for new speed
722 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
724 // Enable breathing interrupt
725 TIMSK1 |= _BV(OCIE1A);
730 void breathing_speed_inc(uint8_t value)
732 if ((uint16_t)(breath_speed - value) > 10 )
734 breathing_speed_set(0);
738 breathing_speed_set(breath_speed - value);
742 void breathing_speed_dec(uint8_t value)
744 if ((uint16_t)(breath_speed + value) > 10 )
746 breathing_speed_set(10);
750 breathing_speed_set(breath_speed + value);
754 void breathing_defaults(void)
756 breathing_intensity_default();
757 breathing_speed_default();
758 breathing_halt = BREATHING_NO_HALT;
761 /* Breathing Sleep LED brighness(PWM On period) table
762 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
764 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
765 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
767 static const uint8_t breathing_table[64] PROGMEM = {
768 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
769 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
770 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
771 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
774 ISR(TIMER1_COMPA_vect)
776 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
779 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
781 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
783 // Disable breathing interrupt
784 TIMSK1 &= ~_BV(OCIE1A);
787 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
797 __attribute__ ((weak))
798 void backlight_init_ports(void)
803 __attribute__ ((weak))
804 void backlight_set(uint8_t level)
812 // Functions for spitting out values
815 void send_dword(uint32_t number) { // this might not actually work
816 uint16_t word = (number >> 16);
818 send_word(number & 0xFFFFUL);
821 void send_word(uint16_t number) {
822 uint8_t byte = number >> 8;
824 send_byte(number & 0xFF);
827 void send_byte(uint8_t number) {
828 uint8_t nibble = number >> 4;
830 send_nibble(number & 0xF);
833 void send_nibble(uint8_t number) {
837 unregister_code(KC_0);
840 register_code(KC_1 + (number - 1));
841 unregister_code(KC_1 + (number - 1));
844 register_code(KC_A + (number - 0xA));
845 unregister_code(KC_A + (number - 0xA));
850 void api_send_unicode(uint32_t unicode) {
853 dword_to_bytes(unicode, chunk);
854 MT_SEND_DATA(DT_UNICODE, chunk, 5);
858 __attribute__ ((weak))
859 void led_set_user(uint8_t usb_led) {
863 __attribute__ ((weak))
864 void led_set_kb(uint8_t usb_led) {
865 led_set_user(usb_led);
868 __attribute__ ((weak))
869 void led_init_ports(void)
874 __attribute__ ((weak))
875 void led_set(uint8_t usb_led)
880 // // Using PE6 Caps Lock LED
881 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
898 //------------------------------------------------------------------------------
899 // Override these functions in your keymap file to play different tunes on
900 // different events such as startup and bootloader jump
902 __attribute__ ((weak))
903 void startup_user() {}
905 __attribute__ ((weak))
906 void shutdown_user() {}
908 //------------------------------------------------------------------------------