3 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
5 case QK_MODS ... QK_MODS_MAX:
30 void register_code16 (uint16_t code) {
31 do_code16 (code, register_code);
35 void unregister_code16 (uint16_t code) {
36 unregister_code (code);
37 do_code16 (code, unregister_code);
40 __attribute__ ((weak))
41 bool process_action_kb(keyrecord_t *record) {
45 __attribute__ ((weak))
46 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
47 return process_record_user(keycode, record);
50 __attribute__ ((weak))
51 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
55 void reset_keyboard(void) {
62 #ifdef CATERINA_BOOTLOADER
63 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
68 // Shift / paren setup
77 static bool shift_interrupted[2] = {0, 0};
79 bool process_record_quantum(keyrecord_t *record) {
81 /* This gets the keycode from the key pressed */
82 keypos_t key = record->event.key;
85 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
86 /* TODO: Use store_or_get_action() or a similar function. */
87 if (!disable_action_cache) {
90 if (record->event.pressed) {
91 layer = layer_switch_get_layer(key);
92 update_source_layers_cache(key, layer);
94 layer = read_source_layers_cache(key);
96 keycode = keymap_key_to_keycode(layer, key);
99 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
101 // This is how you use actions here
102 // if (keycode == KC_LEAD) {
104 // action.code = ACTION_DEFAULT_LAYER_SET(0);
105 // process_action(record, action);
110 process_record_kb(keycode, record) &&
112 process_midi(keycode, record) &&
115 process_music(keycode, record) &&
117 #ifdef TAP_DANCE_ENABLE
118 process_tap_dance(keycode, record) &&
120 #ifndef DISABLE_LEADER
121 process_leader(keycode, record) &&
123 #ifndef DISABLE_CHORDING
124 process_chording(keycode, record) &&
126 #ifdef UNICODE_ENABLE
127 process_unicode(keycode, record) &&
130 process_ucis(keycode, record) &&
132 #ifdef UNICODEMAP_ENABLE
133 process_unicode_map(keycode, record) &&
139 // Shift / paren setup
143 if (record->event.pressed) {
149 if (record->event.pressed) {
150 print("\nDEBUG: enabled.\n");
155 #ifdef RGBLIGHT_ENABLE
157 if (record->event.pressed) {
163 if (record->event.pressed) {
169 if (record->event.pressed) {
170 rgblight_increase_hue();
175 if (record->event.pressed) {
176 rgblight_decrease_hue();
181 if (record->event.pressed) {
182 rgblight_increase_sat();
187 if (record->event.pressed) {
188 rgblight_decrease_sat();
193 if (record->event.pressed) {
194 rgblight_increase_val();
199 if (record->event.pressed) {
200 rgblight_decrease_val();
205 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
206 if (record->event.pressed) {
207 // MAGIC actions (BOOTMAGIC without the boot)
208 if (!eeconfig_is_enabled()) {
212 keymap_config.raw = eeconfig_read_keymap();
215 case MAGIC_SWAP_CONTROL_CAPSLOCK:
216 keymap_config.swap_control_capslock = true;
218 case MAGIC_CAPSLOCK_TO_CONTROL:
219 keymap_config.capslock_to_control = true;
221 case MAGIC_SWAP_LALT_LGUI:
222 keymap_config.swap_lalt_lgui = true;
224 case MAGIC_SWAP_RALT_RGUI:
225 keymap_config.swap_ralt_rgui = true;
228 keymap_config.no_gui = true;
230 case MAGIC_SWAP_GRAVE_ESC:
231 keymap_config.swap_grave_esc = true;
233 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
234 keymap_config.swap_backslash_backspace = true;
236 case MAGIC_HOST_NKRO:
237 keymap_config.nkro = true;
239 case MAGIC_SWAP_ALT_GUI:
240 keymap_config.swap_lalt_lgui = true;
241 keymap_config.swap_ralt_rgui = true;
243 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
244 keymap_config.swap_control_capslock = false;
246 case MAGIC_UNCAPSLOCK_TO_CONTROL:
247 keymap_config.capslock_to_control = false;
249 case MAGIC_UNSWAP_LALT_LGUI:
250 keymap_config.swap_lalt_lgui = false;
252 case MAGIC_UNSWAP_RALT_RGUI:
253 keymap_config.swap_ralt_rgui = false;
256 keymap_config.no_gui = false;
258 case MAGIC_UNSWAP_GRAVE_ESC:
259 keymap_config.swap_grave_esc = false;
261 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
262 keymap_config.swap_backslash_backspace = false;
264 case MAGIC_UNHOST_NKRO:
265 keymap_config.nkro = false;
267 case MAGIC_UNSWAP_ALT_GUI:
268 keymap_config.swap_lalt_lgui = false;
269 keymap_config.swap_ralt_rgui = false;
271 case MAGIC_TOGGLE_NKRO:
272 keymap_config.nkro = !keymap_config.nkro;
277 eeconfig_update_keymap(keymap_config.raw);
278 clear_keyboard(); // clear to prevent stuck keys
284 if (record->event.pressed) {
285 shift_interrupted[0] = false;
286 register_mods(MOD_BIT(KC_LSFT));
289 #ifdef DISABLE_SPACE_CADET_ROLLOVER
290 if (get_mods() & MOD_BIT(KC_RSFT)) {
291 shift_interrupted[0] = true;
292 shift_interrupted[1] = true;
295 if (!shift_interrupted[0]) {
296 register_code(LSPO_KEY);
297 unregister_code(LSPO_KEY);
299 unregister_mods(MOD_BIT(KC_LSFT));
306 if (record->event.pressed) {
307 shift_interrupted[1] = false;
308 register_mods(MOD_BIT(KC_RSFT));
311 #ifdef DISABLE_SPACE_CADET_ROLLOVER
312 if (get_mods() & MOD_BIT(KC_LSFT)) {
313 shift_interrupted[0] = true;
314 shift_interrupted[1] = true;
317 if (!shift_interrupted[1]) {
318 register_code(RSPC_KEY);
319 unregister_code(RSPC_KEY);
321 unregister_mods(MOD_BIT(KC_RSFT));
327 shift_interrupted[0] = true;
328 shift_interrupted[1] = true;
333 return process_action_kb(record);
336 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
337 0, 0, 0, 0, 0, 0, 0, 0,
338 0, 0, 0, 0, 0, 0, 0, 0,
339 0, 0, 0, 0, 0, 0, 0, 0,
340 0, 0, 0, 0, 0, 0, 0, 0,
341 0, 1, 1, 1, 1, 1, 1, 0,
342 1, 1, 1, 1, 0, 0, 0, 0,
343 0, 0, 0, 0, 0, 0, 0, 0,
344 0, 0, 1, 0, 1, 0, 1, 1,
345 1, 1, 1, 1, 1, 1, 1, 1,
346 1, 1, 1, 1, 1, 1, 1, 1,
347 1, 1, 1, 1, 1, 1, 1, 1,
348 1, 1, 1, 0, 0, 0, 1, 1,
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, 1, 1, 1, 1, 0
355 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
356 0, 0, 0, 0, 0, 0, 0, 0,
357 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
358 0, 0, 0, 0, 0, 0, 0, 0,
359 0, 0, 0, KC_ESC, 0, 0, 0, 0,
360 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
361 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
362 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
363 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
364 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
365 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
366 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
367 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
368 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
369 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
370 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
371 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
374 /* for users whose OSes are set to Colemak */
376 #include "keymap_colemak.h"
378 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
379 0, 0, 0, 0, 0, 0, 0, 0,
380 0, 0, 0, 0, 0, 0, 0, 0,
381 0, 0, 0, 0, 0, 0, 0, 0,
382 0, 0, 0, 0, 0, 0, 0, 0,
383 0, 1, 1, 1, 1, 1, 1, 0,
384 1, 1, 1, 1, 0, 0, 0, 0,
385 0, 0, 0, 0, 0, 0, 0, 0,
386 0, 0, 1, 0, 1, 0, 1, 1,
387 1, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 1,
389 1, 1, 1, 1, 1, 1, 1, 1,
390 1, 1, 1, 0, 0, 0, 1, 1,
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, 1, 1, 1, 1, 0
397 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
398 0, 0, 0, 0, 0, 0, 0, 0,
399 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
400 0, 0, 0, 0, 0, 0, 0, 0,
401 0, 0, 0, KC_ESC, 0, 0, 0, 0,
402 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
403 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
404 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
405 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
406 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
407 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
408 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
409 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
410 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
411 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
412 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
413 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
418 void send_string(const char *str) {
421 uint8_t ascii_code = pgm_read_byte(str);
422 if (!ascii_code) break;
423 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
424 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
425 register_code(KC_LSFT);
426 register_code(keycode);
427 unregister_code(keycode);
428 unregister_code(KC_LSFT);
431 register_code(keycode);
432 unregister_code(keycode);
438 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
439 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
446 void tap_random_base64(void) {
447 #if defined(__AVR_ATmega32U4__)
448 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
450 uint8_t key = rand() % 64;
454 register_code(KC_LSFT);
455 register_code(key + KC_A);
456 unregister_code(key + KC_A);
457 unregister_code(KC_LSFT);
460 register_code(key - 26 + KC_A);
461 unregister_code(key - 26 + KC_A);
465 unregister_code(KC_0);
468 register_code(key - 53 + KC_1);
469 unregister_code(key - 53 + KC_1);
472 register_code(KC_LSFT);
473 register_code(KC_EQL);
474 unregister_code(KC_EQL);
475 unregister_code(KC_LSFT);
478 register_code(KC_SLSH);
479 unregister_code(KC_SLSH);
484 void matrix_init_quantum() {
485 #ifdef BACKLIGHT_ENABLE
486 backlight_init_ports();
491 void matrix_scan_quantum() {
496 #ifdef TAP_DANCE_ENABLE
497 matrix_scan_tap_dance();
502 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
504 static const uint8_t backlight_pin = BACKLIGHT_PIN;
506 #if BACKLIGHT_PIN == B7
507 # define COM1x1 COM1C1
509 #elif BACKLIGHT_PIN == B6
510 # define COM1x1 COM1B1
512 #elif BACKLIGHT_PIN == B5
513 # define COM1x1 COM1A1
516 # error "Backlight pin not supported - use B5, B6, or B7"
519 __attribute__ ((weak))
520 void backlight_init_ports(void)
523 // Setup backlight pin as output and output low.
525 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
527 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
529 // Use full 16-bit resolution.
532 // I could write a wall of text here to explain... but TL;DW
533 // Go read the ATmega32u4 datasheet.
534 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
536 // Pin PB7 = OCR1C (Timer 1, Channel C)
537 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
538 // (i.e. start high, go low when counter matches.)
539 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
540 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
542 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
543 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
546 #ifdef BACKLIGHT_BREATHING
547 breathing_defaults();
551 __attribute__ ((weak))
552 void backlight_set(uint8_t level)
554 // Prevent backlight blink on lowest level
556 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
559 // Turn off PWM control on backlight pin, revert to output low.
560 TCCR1A &= ~(_BV(COM1x1));
562 } else if ( level == BACKLIGHT_LEVELS ) {
563 // Turn on PWM control of backlight pin
564 TCCR1A |= _BV(COM1x1);
565 // Set the brightness
568 // Turn on PWM control of backlight pin
569 TCCR1A |= _BV(COM1x1);
570 // Set the brightness
571 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
574 #ifdef BACKLIGHT_BREATHING
575 breathing_intensity_default();
580 #ifdef BACKLIGHT_BREATHING
582 #define BREATHING_NO_HALT 0
583 #define BREATHING_HALT_OFF 1
584 #define BREATHING_HALT_ON 2
586 static uint8_t breath_intensity;
587 static uint8_t breath_speed;
588 static uint16_t breathing_index;
589 static uint8_t breathing_halt;
591 void breathing_enable(void)
593 if (get_backlight_level() == 0)
599 // Set breathing_index to be at the midpoint (brightest point)
600 breathing_index = 0x20 << breath_speed;
603 breathing_halt = BREATHING_NO_HALT;
605 // Enable breathing interrupt
606 TIMSK1 |= _BV(OCIE1A);
609 void breathing_pulse(void)
611 if (get_backlight_level() == 0)
617 // Set breathing_index to be at the midpoint + 1 (brightest point)
618 breathing_index = 0x21 << breath_speed;
621 breathing_halt = BREATHING_HALT_ON;
623 // Enable breathing interrupt
624 TIMSK1 |= _BV(OCIE1A);
627 void breathing_disable(void)
629 // Disable breathing interrupt
630 TIMSK1 &= ~_BV(OCIE1A);
631 backlight_set(get_backlight_level());
634 void breathing_self_disable(void)
636 if (get_backlight_level() == 0)
638 breathing_halt = BREATHING_HALT_OFF;
642 breathing_halt = BREATHING_HALT_ON;
645 //backlight_set(get_backlight_level());
648 void breathing_toggle(void)
652 if (get_backlight_level() == 0)
658 // Set breathing_index to be at the midpoint + 1 (brightest point)
659 breathing_index = 0x21 << breath_speed;
662 breathing_halt = BREATHING_NO_HALT;
665 // Toggle breathing interrupt
666 TIMSK1 ^= _BV(OCIE1A);
668 // Restore backlight level
671 backlight_set(get_backlight_level());
675 bool is_breathing(void)
677 return (TIMSK1 && _BV(OCIE1A));
680 void breathing_intensity_default(void)
682 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
683 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
686 void breathing_intensity_set(uint8_t value)
688 breath_intensity = value;
691 void breathing_speed_default(void)
696 void breathing_speed_set(uint8_t value)
698 bool is_breathing_now = is_breathing();
699 uint8_t old_breath_speed = breath_speed;
701 if (is_breathing_now)
703 // Disable breathing interrupt
704 TIMSK1 &= ~_BV(OCIE1A);
707 breath_speed = value;
709 if (is_breathing_now)
711 // Adjust index to account for new speed
712 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
714 // Enable breathing interrupt
715 TIMSK1 |= _BV(OCIE1A);
720 void breathing_speed_inc(uint8_t value)
722 if ((uint16_t)(breath_speed - value) > 10 )
724 breathing_speed_set(0);
728 breathing_speed_set(breath_speed - value);
732 void breathing_speed_dec(uint8_t value)
734 if ((uint16_t)(breath_speed + value) > 10 )
736 breathing_speed_set(10);
740 breathing_speed_set(breath_speed + value);
744 void breathing_defaults(void)
746 breathing_intensity_default();
747 breathing_speed_default();
748 breathing_halt = BREATHING_NO_HALT;
751 /* Breathing Sleep LED brighness(PWM On period) table
752 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
754 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
755 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
757 static const uint8_t breathing_table[64] PROGMEM = {
758 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
759 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
760 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
761 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
764 ISR(TIMER1_COMPA_vect)
766 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
769 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
771 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
773 // Disable breathing interrupt
774 TIMSK1 &= ~_BV(OCIE1A);
777 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
787 __attribute__ ((weak))
788 void backlight_init_ports(void)
793 __attribute__ ((weak))
794 void backlight_set(uint8_t level)
803 __attribute__ ((weak))
804 void led_set_user(uint8_t usb_led) {
808 __attribute__ ((weak))
809 void led_set_kb(uint8_t usb_led) {
810 led_set_user(usb_led);
813 __attribute__ ((weak))
814 void led_init_ports(void)
819 __attribute__ ((weak))
820 void led_set(uint8_t usb_led)
825 // // Using PE6 Caps Lock LED
826 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
843 //------------------------------------------------------------------------------
844 // Override these functions in your keymap file to play different tunes on
845 // different events such as startup and bootloader jump
847 __attribute__ ((weak))
848 void startup_user() {}
850 __attribute__ ((weak))
851 void shutdown_user() {}
853 //------------------------------------------------------------------------------