4 bool process_action_kb(keyrecord_t *record) {
9 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
10 return process_record_user(keycode, record);
13 __attribute__ ((weak))
14 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
18 // Shift / paren setup
27 static bool shift_interrupted[2] = {0, 0};
29 bool process_record_quantum(keyrecord_t *record) {
31 /* This gets the keycode from the key pressed */
32 keypos_t key = record->event.key;
35 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
38 if (record->event.pressed) {
39 layer = layer_switch_get_layer(key);
40 update_source_layers_cache(key, layer);
42 layer = read_source_layers_cache(key);
44 keycode = keymap_key_to_keycode(layer, key);
46 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
49 // This is how you use actions here
50 // if (keycode == KC_LEAD) {
52 // action.code = ACTION_DEFAULT_LAYER_SET(0);
53 // process_action(record, action);
58 process_record_kb(keycode, record) &&
60 process_midi(keycode, record) &&
63 process_music(keycode, record) &&
65 #ifdef TAP_DANCE_ENABLE
66 process_tap_dance(keycode, record) &&
68 #ifndef DISABLE_LEADER
69 process_leader(keycode, record) &&
71 #ifndef DISABLE_CHORDING
72 process_chording(keycode, record) &&
75 process_unicode(keycode, record) &&
81 // Shift / paren setup
85 if (record->event.pressed) {
93 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
100 if (record->event.pressed) {
101 print("\nDEBUG: enabled.\n");
106 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI:
107 if (record->event.pressed) {
108 // MAGIC actions (BOOTMAGIC without the boot)
109 if (!eeconfig_is_enabled()) {
113 keymap_config.raw = eeconfig_read_keymap();
114 if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) {
115 keymap_config.swap_control_capslock = 1;
116 } else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) {
117 keymap_config.capslock_to_control = 1;
118 } else if (keycode == MAGIC_SWAP_LALT_LGUI) {
119 keymap_config.swap_lalt_lgui = 1;
120 } else if (keycode == MAGIC_SWAP_RALT_RGUI) {
121 keymap_config.swap_ralt_rgui = 1;
122 } else if (keycode == MAGIC_NO_GUI) {
123 keymap_config.no_gui = 1;
124 } else if (keycode == MAGIC_SWAP_GRAVE_ESC) {
125 keymap_config.swap_grave_esc = 1;
126 } else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) {
127 keymap_config.swap_backslash_backspace = 1;
128 } else if (keycode == MAGIC_HOST_NKRO) {
129 keymap_config.nkro = 1;
130 } else if (keycode == MAGIC_SWAP_ALT_GUI) {
131 keymap_config.swap_lalt_lgui = 1;
132 keymap_config.swap_ralt_rgui = 1;
135 else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) {
136 keymap_config.swap_control_capslock = 0;
137 } else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) {
138 keymap_config.capslock_to_control = 0;
139 } else if (keycode == MAGIC_UNSWAP_LALT_LGUI) {
140 keymap_config.swap_lalt_lgui = 0;
141 } else if (keycode == MAGIC_UNSWAP_RALT_RGUI) {
142 keymap_config.swap_ralt_rgui = 0;
143 } else if (keycode == MAGIC_UNNO_GUI) {
144 keymap_config.no_gui = 0;
145 } else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) {
146 keymap_config.swap_grave_esc = 0;
147 } else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) {
148 keymap_config.swap_backslash_backspace = 0;
149 } else if (keycode == MAGIC_UNHOST_NKRO) {
150 keymap_config.nkro = 0;
151 } else if (keycode == MAGIC_UNSWAP_ALT_GUI) {
152 keymap_config.swap_lalt_lgui = 0;
153 keymap_config.swap_ralt_rgui = 0;
155 eeconfig_update_keymap(keymap_config.raw);
160 if (record->event.pressed) {
161 shift_interrupted[0] = false;
162 register_mods(MOD_BIT(KC_LSFT));
165 if (!shift_interrupted[0]) {
166 register_code(LSPO_KEY);
167 unregister_code(LSPO_KEY);
169 unregister_mods(MOD_BIT(KC_LSFT));
176 if (record->event.pressed) {
177 shift_interrupted[1] = false;
178 register_mods(MOD_BIT(KC_RSFT));
181 if (!shift_interrupted[1]) {
182 register_code(RSPC_KEY);
183 unregister_code(RSPC_KEY);
185 unregister_mods(MOD_BIT(KC_RSFT));
191 shift_interrupted[0] = true;
192 shift_interrupted[1] = true;
197 return process_action_kb(record);
200 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
201 0, 0, 0, 0, 0, 0, 0, 0,
202 0, 0, 0, 0, 0, 0, 0, 0,
203 0, 0, 0, 0, 0, 0, 0, 0,
204 0, 0, 0, 0, 0, 0, 0, 0,
205 0, 1, 1, 1, 1, 1, 1, 0,
206 1, 1, 1, 1, 0, 0, 0, 0,
207 0, 0, 0, 0, 0, 0, 0, 0,
208 0, 0, 1, 0, 1, 0, 1, 1,
209 1, 1, 1, 1, 1, 1, 1, 1,
210 1, 1, 1, 1, 1, 1, 1, 1,
211 1, 1, 1, 1, 1, 1, 1, 1,
212 1, 1, 1, 0, 0, 0, 1, 1,
213 0, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 0, 0, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 0, 0,
216 0, 0, 0, 1, 1, 1, 1, 0
219 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
220 0, 0, 0, 0, 0, 0, 0, 0,
221 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
222 0, 0, 0, 0, 0, 0, 0, 0,
223 0, 0, 0, KC_ESC, 0, 0, 0, 0,
224 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
225 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
226 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
227 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
228 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
229 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
230 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
231 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
232 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
233 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
234 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
235 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
238 /* for users whose OSes are set to Colemak */
240 #include "keymap_colemak.h"
242 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
243 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 0, 0,
246 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 1, 1, 1, 1, 1, 1, 0,
248 1, 1, 1, 1, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 1, 0, 1, 0, 1, 1,
251 1, 1, 1, 1, 1, 1, 1, 1,
252 1, 1, 1, 1, 1, 1, 1, 1,
253 1, 1, 1, 1, 1, 1, 1, 1,
254 1, 1, 1, 0, 0, 0, 1, 1,
255 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0,
258 0, 0, 0, 1, 1, 1, 1, 0
261 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
262 0, 0, 0, 0, 0, 0, 0, 0,
263 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
264 0, 0, 0, 0, 0, 0, 0, 0,
265 0, 0, 0, KC_ESC, 0, 0, 0, 0,
266 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
267 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
268 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
269 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
270 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
271 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
272 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
273 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
274 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
275 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
276 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
277 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
282 void send_string(const char *str) {
285 uint8_t ascii_code = pgm_read_byte(str);
286 if (!ascii_code) break;
287 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
288 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
289 register_code(KC_LSFT);
290 register_code(keycode);
291 unregister_code(keycode);
292 unregister_code(KC_LSFT);
295 register_code(keycode);
296 unregister_code(keycode);
302 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
303 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
310 void tap_random_base64(void) {
311 #if defined(__AVR_ATmega32U4__)
312 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
314 uint8_t key = rand() % 64;
318 register_code(KC_LSFT);
319 register_code(key + KC_A);
320 unregister_code(key + KC_A);
321 unregister_code(KC_LSFT);
324 register_code(key - 26 + KC_A);
325 unregister_code(key - 26 + KC_A);
329 unregister_code(KC_0);
332 register_code(key - 53 + KC_1);
333 unregister_code(key - 53 + KC_1);
336 register_code(KC_LSFT);
337 register_code(KC_EQL);
338 unregister_code(KC_EQL);
339 unregister_code(KC_LSFT);
342 register_code(KC_SLSH);
343 unregister_code(KC_SLSH);
348 void matrix_init_quantum() {
349 #ifdef BACKLIGHT_ENABLE
350 backlight_init_ports();
355 void matrix_scan_quantum() {
360 #ifdef TAP_DANCE_ENABLE
361 matrix_scan_tap_dance();
366 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
368 static const uint8_t backlight_pin = BACKLIGHT_PIN;
370 #if BACKLIGHT_PIN == B7
371 # define COM1x1 COM1C1
373 #elif BACKLIGHT_PIN == B6
374 # define COM1x1 COM1B1
376 #elif BACKLIGHT_PIN == B5
377 # define COM1x1 COM1A1
380 # error "Backlight pin not supported - use B5, B6, or B7"
383 __attribute__ ((weak))
384 void backlight_init_ports(void)
387 // Setup backlight pin as output and output low.
389 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
391 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
393 // Use full 16-bit resolution.
396 // I could write a wall of text here to explain... but TL;DW
397 // Go read the ATmega32u4 datasheet.
398 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
400 // Pin PB7 = OCR1C (Timer 1, Channel C)
401 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
402 // (i.e. start high, go low when counter matches.)
403 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
404 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
406 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
407 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
410 #ifdef BACKLIGHT_BREATHING
411 breathing_defaults();
415 __attribute__ ((weak))
416 void backlight_set(uint8_t level)
418 // Prevent backlight blink on lowest level
420 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
423 // Turn off PWM control on backlight pin, revert to output low.
424 TCCR1A &= ~(_BV(COM1x1));
426 } else if ( level == BACKLIGHT_LEVELS ) {
427 // Turn on PWM control of backlight pin
428 TCCR1A |= _BV(COM1x1);
429 // Set the brightness
432 // Turn on PWM control of backlight pin
433 TCCR1A |= _BV(COM1x1);
434 // Set the brightness
435 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
438 #ifdef BACKLIGHT_BREATHING
439 breathing_intensity_default();
444 #ifdef BACKLIGHT_BREATHING
446 #define BREATHING_NO_HALT 0
447 #define BREATHING_HALT_OFF 1
448 #define BREATHING_HALT_ON 2
450 static uint8_t breath_intensity;
451 static uint8_t breath_speed;
452 static uint16_t breathing_index;
453 static uint8_t breathing_halt;
455 void breathing_enable(void)
457 if (get_backlight_level() == 0)
463 // Set breathing_index to be at the midpoint (brightest point)
464 breathing_index = 0x20 << breath_speed;
467 breathing_halt = BREATHING_NO_HALT;
469 // Enable breathing interrupt
470 TIMSK1 |= _BV(OCIE1A);
473 void breathing_pulse(void)
475 if (get_backlight_level() == 0)
481 // Set breathing_index to be at the midpoint + 1 (brightest point)
482 breathing_index = 0x21 << breath_speed;
485 breathing_halt = BREATHING_HALT_ON;
487 // Enable breathing interrupt
488 TIMSK1 |= _BV(OCIE1A);
491 void breathing_disable(void)
493 // Disable breathing interrupt
494 TIMSK1 &= ~_BV(OCIE1A);
495 backlight_set(get_backlight_level());
498 void breathing_self_disable(void)
500 if (get_backlight_level() == 0)
502 breathing_halt = BREATHING_HALT_OFF;
506 breathing_halt = BREATHING_HALT_ON;
509 //backlight_set(get_backlight_level());
512 void breathing_toggle(void)
516 if (get_backlight_level() == 0)
522 // Set breathing_index to be at the midpoint + 1 (brightest point)
523 breathing_index = 0x21 << breath_speed;
526 breathing_halt = BREATHING_NO_HALT;
529 // Toggle breathing interrupt
530 TIMSK1 ^= _BV(OCIE1A);
532 // Restore backlight level
535 backlight_set(get_backlight_level());
539 bool is_breathing(void)
541 return (TIMSK1 && _BV(OCIE1A));
544 void breathing_intensity_default(void)
546 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
547 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
550 void breathing_intensity_set(uint8_t value)
552 breath_intensity = value;
555 void breathing_speed_default(void)
560 void breathing_speed_set(uint8_t value)
562 bool is_breathing_now = is_breathing();
563 uint8_t old_breath_speed = breath_speed;
565 if (is_breathing_now)
567 // Disable breathing interrupt
568 TIMSK1 &= ~_BV(OCIE1A);
571 breath_speed = value;
573 if (is_breathing_now)
575 // Adjust index to account for new speed
576 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
578 // Enable breathing interrupt
579 TIMSK1 |= _BV(OCIE1A);
584 void breathing_speed_inc(uint8_t value)
586 if ((uint16_t)(breath_speed - value) > 10 )
588 breathing_speed_set(0);
592 breathing_speed_set(breath_speed - value);
596 void breathing_speed_dec(uint8_t value)
598 if ((uint16_t)(breath_speed + value) > 10 )
600 breathing_speed_set(10);
604 breathing_speed_set(breath_speed + value);
608 void breathing_defaults(void)
610 breathing_intensity_default();
611 breathing_speed_default();
612 breathing_halt = BREATHING_NO_HALT;
615 /* Breathing Sleep LED brighness(PWM On period) table
616 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
618 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
619 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
621 static const uint8_t breathing_table[64] PROGMEM = {
622 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
623 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
624 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
625 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
628 ISR(TIMER1_COMPA_vect)
630 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
633 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
635 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
637 // Disable breathing interrupt
638 TIMSK1 &= ~_BV(OCIE1A);
641 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
651 __attribute__ ((weak))
652 void backlight_init_ports(void)
657 __attribute__ ((weak))
658 void backlight_set(uint8_t level)
667 __attribute__ ((weak))
668 void led_set_user(uint8_t usb_led) {
672 __attribute__ ((weak))
673 void led_set_kb(uint8_t usb_led) {
674 led_set_user(usb_led);
677 __attribute__ ((weak))
678 void led_init_ports(void)
683 __attribute__ ((weak))
684 void led_set(uint8_t usb_led)
689 // // Using PE6 Caps Lock LED
690 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
707 //------------------------------------------------------------------------------
708 // Override these functions in your keymap file to play different tunes on
709 // different events such as startup and bootloader jump
711 __attribute__ ((weak))
712 void startup_user() {}
714 __attribute__ ((weak))
715 void shutdown_user() {}
717 //------------------------------------------------------------------------------