4 void matrix_init_kb(void) {}
7 void matrix_scan_kb(void) {}
10 bool process_action_kb(keyrecord_t *record) {
14 __attribute__ ((weak))
15 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
16 return process_record_user(keycode, record);
19 __attribute__ ((weak))
20 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
24 __attribute__ ((weak))
25 void leader_start(void) {}
27 __attribute__ ((weak))
28 void leader_end(void) {}
30 uint8_t starting_note = 0x0C;
35 bool music_activated = false;
38 static bool music_sequence_recording = false;
39 static bool music_sequence_playing = false;
40 static float music_sequence[16] = {0};
41 static uint8_t music_sequence_count = 0;
42 static uint8_t music_sequence_position = 0;
44 static uint16_t music_sequence_timer = 0;
45 static uint16_t music_sequence_interval = 100;
50 bool midi_activated = false;
55 uint16_t leader_time = 0;
57 uint16_t leader_sequence[3] = {0, 0, 0};
58 uint8_t leader_sequence_size = 0;
61 #define CHORDING_MAX 4
62 bool chording = false;
64 uint8_t chord_keys[CHORDING_MAX] = {0};
65 uint8_t chord_key_count = 0;
66 uint8_t chord_key_down = 0;
69 static uint8_t input_mode;
72 // Shift / paren setup
81 static bool shift_interrupted[2] = {0, 0};
83 bool keys_chord(uint8_t keys[]) {
84 uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
87 for (uint8_t i = 0; i < chord_key_count; i++) {
89 for (uint8_t j = 0; j < keys_size; j++) {
90 if (chord_keys[i] == (keys[j] & 0xFF)) {
91 in++; // detects key in chord
98 if (chord_keys[i] != 0) {
99 pass = false; // makes sure rest are blank
102 return (pass && (in == keys_size));
105 #ifdef UNICODE_ENABLE
107 uint16_t hex_to_keycode(uint8_t hex)
111 } else if (hex < 0xA) {
112 return KC_1 + (hex - 0x1);
114 return KC_A + (hex - 0xA);
118 void set_unicode_mode(uint8_t os_target)
120 input_mode = os_target;
125 bool process_record_quantum(keyrecord_t *record) {
127 /* This gets the keycode from the key pressed */
128 keypos_t key = record->event.key;
131 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
134 if (record->event.pressed) {
135 layer = layer_switch_get_layer(key);
136 update_source_layers_cache(key, layer);
138 layer = read_source_layers_cache(key);
140 keycode = keymap_key_to_keycode(layer, key);
142 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
145 if (!process_record_kb(keycode, record))
148 // This is how you use actions here
149 // if (keycode == KC_LEAD) {
151 // action.code = ACTION_DEFAULT_LAYER_SET(0);
152 // process_action(record, action);
157 if (keycode == MI_ON && record->event.pressed) {
158 midi_activated = true;
163 if (keycode == MI_OFF && record->event.pressed) {
164 midi_activated = false;
165 midi_send_cc(&midi_device, 0, 0x7B, 0);
169 if (midi_activated) {
170 if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
171 if (record->event.pressed) {
172 starting_note++; // Change key
173 midi_send_cc(&midi_device, 0, 0x7B, 0);
177 if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
178 if (record->event.pressed) {
179 starting_note--; // Change key
180 midi_send_cc(&midi_device, 0, 0x7B, 0);
184 if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
185 offset++; // Change scale
186 midi_send_cc(&midi_device, 0, 0x7B, 0);
189 if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
190 offset--; // Change scale
191 midi_send_cc(&midi_device, 0, 0x7B, 0);
195 // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
197 // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
199 uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
201 // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
203 if (record->event.pressed) {
204 // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
205 midi_send_noteon(&midi_device, 0, note, 127);
207 // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
208 midi_send_noteoff(&midi_device, 0, note, 127);
211 if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
217 if (keycode == AU_ON && record->event.pressed) {
222 if (keycode == AU_OFF && record->event.pressed) {
227 if (keycode == AU_TOG && record->event.pressed) {
239 if (keycode == MU_ON && record->event.pressed) {
244 if (keycode == MU_OFF && record->event.pressed) {
249 if (keycode == MU_TOG && record->event.pressed) {
261 if (keycode == MUV_IN && record->event.pressed) {
267 if (keycode == MUV_DE && record->event.pressed) {
273 if (music_activated) {
275 if (keycode == KC_LCTL && record->event.pressed) { // Start recording
277 music_sequence_recording = true;
278 music_sequence_playing = false;
279 music_sequence_count = 0;
283 if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
285 music_sequence_recording = false;
286 music_sequence_playing = false;
290 if (keycode == KC_LGUI && record->event.pressed) { // Start playing
292 music_sequence_recording = false;
293 music_sequence_playing = true;
294 music_sequence_position = 0;
295 music_sequence_timer = 0;
299 if (keycode == KC_UP) {
300 if (record->event.pressed)
301 music_sequence_interval-=10;
305 if (keycode == KC_DOWN) {
306 if (record->event.pressed)
307 music_sequence_interval+=10;
311 float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
312 if (record->event.pressed) {
313 play_note(freq, 0xF);
314 if (music_sequence_recording) {
315 music_sequence[music_sequence_count] = freq;
316 music_sequence_count++;
322 if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
327 #ifndef DISABLE_LEADER
329 if (record->event.pressed) {
330 if (!leading && keycode == KC_LEAD) {
333 leader_time = timer_read();
334 leader_sequence_size = 0;
335 leader_sequence[0] = 0;
336 leader_sequence[1] = 0;
337 leader_sequence[2] = 0;
340 if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
341 leader_sequence[leader_sequence_size] = keycode;
342 leader_sequence_size++;
348 #define DISABLE_CHORDING
349 #ifndef DISABLE_CHORDING
351 if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
352 if (record->event.pressed) {
355 for (uint8_t i = 0; i < CHORDING_MAX; i++)
360 chord_keys[chord_key_count] = (keycode & 0xFF);
367 if (chord_key_down == 0) {
370 if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
372 unregister_code(KC_A);
375 for (uint8_t i = 0; i < chord_key_count; i++) {
376 register_code(chord_keys[i]);
377 unregister_code(chord_keys[i]);
387 #ifdef UNICODE_ENABLE
389 if (keycode > QK_UNICODE && record->event.pressed) {
390 uint16_t unicode = keycode & 0x7FFF;
393 register_code(KC_LALT);
396 register_code(KC_LCTL);
397 register_code(KC_LSFT);
399 unregister_code(KC_U);
402 register_code(KC_LALT);
403 register_code(KC_PPLS);
404 unregister_code(KC_PPLS);
407 for(int i = 3; i >= 0; i--) {
408 uint8_t digit = ((unicode >> (i*4)) & 0xF);
409 register_code(hex_to_keycode(digit));
410 unregister_code(hex_to_keycode(digit));
415 unregister_code(KC_LALT);
418 unregister_code(KC_LCTL);
419 unregister_code(KC_LSFT);
426 // Shift / paren setup
430 if (record->event.pressed) {
438 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
445 if (record->event.pressed) {
446 print("\nDEBUG: enabled.\n");
451 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI:
452 if (record->event.pressed) {
453 // MAGIC actions (BOOTMAGIC without the boot)
454 if (!eeconfig_is_enabled()) {
458 keymap_config.raw = eeconfig_read_keymap();
459 if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) {
460 keymap_config.swap_control_capslock = 1;
461 } else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) {
462 keymap_config.capslock_to_control = 1;
463 } else if (keycode == MAGIC_SWAP_LALT_LGUI) {
464 keymap_config.swap_lalt_lgui = 1;
465 } else if (keycode == MAGIC_SWAP_RALT_RGUI) {
466 keymap_config.swap_ralt_rgui = 1;
467 } else if (keycode == MAGIC_NO_GUI) {
468 keymap_config.no_gui = 1;
469 } else if (keycode == MAGIC_SWAP_GRAVE_ESC) {
470 keymap_config.swap_grave_esc = 1;
471 } else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) {
472 keymap_config.swap_backslash_backspace = 1;
473 } else if (keycode == MAGIC_HOST_NKRO) {
474 keymap_config.nkro = 1;
475 } else if (keycode == MAGIC_SWAP_ALT_GUI) {
476 keymap_config.swap_lalt_lgui = 1;
477 keymap_config.swap_ralt_rgui = 1;
480 else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) {
481 keymap_config.swap_control_capslock = 0;
482 } else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) {
483 keymap_config.capslock_to_control = 0;
484 } else if (keycode == MAGIC_UNSWAP_LALT_LGUI) {
485 keymap_config.swap_lalt_lgui = 0;
486 } else if (keycode == MAGIC_UNSWAP_RALT_RGUI) {
487 keymap_config.swap_ralt_rgui = 0;
488 } else if (keycode == MAGIC_UNNO_GUI) {
489 keymap_config.no_gui = 0;
490 } else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) {
491 keymap_config.swap_grave_esc = 0;
492 } else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) {
493 keymap_config.swap_backslash_backspace = 0;
494 } else if (keycode == MAGIC_UNHOST_NKRO) {
495 keymap_config.nkro = 0;
496 } else if (keycode == MAGIC_UNSWAP_ALT_GUI) {
497 keymap_config.swap_lalt_lgui = 0;
498 keymap_config.swap_ralt_rgui = 0;
500 eeconfig_update_keymap(keymap_config.raw);
505 if (record->event.pressed) {
506 shift_interrupted[0] = false;
507 register_mods(MOD_BIT(KC_LSFT));
510 if (!shift_interrupted[0]) {
511 register_code(LSPO_KEY);
512 unregister_code(LSPO_KEY);
514 unregister_mods(MOD_BIT(KC_LSFT));
521 if (record->event.pressed) {
522 shift_interrupted[1] = false;
523 register_mods(MOD_BIT(KC_RSFT));
526 if (!shift_interrupted[1]) {
527 register_code(RSPC_KEY);
528 unregister_code(RSPC_KEY);
530 unregister_mods(MOD_BIT(KC_RSFT));
536 shift_interrupted[0] = true;
537 shift_interrupted[1] = true;
542 return process_action_kb(record);
545 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
546 0, 0, 0, 0, 0, 0, 0, 0,
547 0, 0, 0, 0, 0, 0, 0, 0,
548 0, 0, 0, 0, 0, 0, 0, 0,
549 0, 0, 0, 0, 0, 0, 0, 0,
550 0, 1, 1, 1, 1, 1, 1, 0,
551 1, 1, 1, 1, 0, 0, 0, 0,
552 0, 0, 0, 0, 0, 0, 0, 0,
553 0, 0, 1, 0, 1, 0, 1, 1,
554 1, 1, 1, 1, 1, 1, 1, 1,
555 1, 1, 1, 1, 1, 1, 1, 1,
556 1, 1, 1, 1, 1, 1, 1, 1,
557 1, 1, 1, 0, 0, 0, 1, 1,
558 0, 0, 0, 0, 0, 0, 0, 0,
559 0, 0, 0, 0, 0, 0, 0, 0,
560 0, 0, 0, 0, 0, 0, 0, 0,
561 0, 0, 0, 1, 1, 1, 1, 0
564 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
565 0, 0, 0, 0, 0, 0, 0, 0,
566 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
567 0, 0, 0, 0, 0, 0, 0, 0,
568 0, 0, 0, KC_ESC, 0, 0, 0, 0,
569 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
570 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
571 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
572 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
573 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
574 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
575 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
576 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
577 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
578 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
579 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
580 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
583 /* for users whose OSes are set to Colemak */
585 #include "keymap_colemak.h"
587 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
588 0, 0, 0, 0, 0, 0, 0, 0,
589 0, 0, 0, 0, 0, 0, 0, 0,
590 0, 0, 0, 0, 0, 0, 0, 0,
591 0, 0, 0, 0, 0, 0, 0, 0,
592 0, 1, 1, 1, 1, 1, 1, 0,
593 1, 1, 1, 1, 0, 0, 0, 0,
594 0, 0, 0, 0, 0, 0, 0, 0,
595 0, 0, 1, 0, 1, 0, 1, 1,
596 1, 1, 1, 1, 1, 1, 1, 1,
597 1, 1, 1, 1, 1, 1, 1, 1,
598 1, 1, 1, 1, 1, 1, 1, 1,
599 1, 1, 1, 0, 0, 0, 1, 1,
600 0, 0, 0, 0, 0, 0, 0, 0,
601 0, 0, 0, 0, 0, 0, 0, 0,
602 0, 0, 0, 0, 0, 0, 0, 0,
603 0, 0, 0, 1, 1, 1, 1, 0
606 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
607 0, 0, 0, 0, 0, 0, 0, 0,
608 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
609 0, 0, 0, 0, 0, 0, 0, 0,
610 0, 0, 0, KC_ESC, 0, 0, 0, 0,
611 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
612 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
613 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
614 KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
615 KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
616 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
617 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
618 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
619 KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
620 CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
621 CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
622 CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
627 void send_string(const char *str) {
630 uint8_t ascii_code = pgm_read_byte(str);
631 if (!ascii_code) break;
632 keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
633 if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
634 register_code(KC_LSFT);
635 register_code(keycode);
636 unregister_code(keycode);
637 unregister_code(KC_LSFT);
640 register_code(keycode);
641 unregister_code(keycode);
647 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
648 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
655 void matrix_init_quantum() {
659 void matrix_scan_quantum() {
661 if (music_sequence_playing) {
662 if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
663 music_sequence_timer = timer_read();
664 stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
665 play_note(music_sequence[music_sequence_position], 0xF);
666 music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
675 bool is_music_on(void) {
676 return (music_activated != 0);
679 void music_toggle(void) {
680 if (!music_activated) {
687 void music_on(void) {
692 void music_off(void) {
699 //------------------------------------------------------------------------------
700 // Override these functions in your keymap file to play different tunes on
701 // different events such as startup and bootloader jump
703 __attribute__ ((weak))
704 void startup_user() {}
706 __attribute__ ((weak))
707 void shutdown_user() {}
709 __attribute__ ((weak))
710 void music_on_user() {}
712 __attribute__ ((weak))
713 void audio_on_user() {}
715 __attribute__ ((weak))
716 void music_scale_user() {}
718 //------------------------------------------------------------------------------