quantum/quantum.c

   1 #include "quantum.h"
   2
   3 __attribute__ ((weak))
   4 void matrix_init_kb(void) {}
   5
   6 __attribute__ ((weak))
   7 void matrix_scan_kb(void) {}
   8
   9 __attribute__ ((weak))
  10 bool process_action_kb(keyrecord_t *record) {
  11   return true;
  12 }
  13
  14 __attribute__ ((weak))
  15 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
  16   return process_record_user(keycode, record);
  17 }
  18
  19 __attribute__ ((weak))
  20 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  21   return true;
  22 }
  23
  24 __attribute__ ((weak))
  25 void leader_start(void) {}
  26
  27 __attribute__ ((weak))
  28 void leader_end(void) {}
  29
  30 uint8_t starting_note = 0x0C;
  31 int offset = 7;
  32
  33
  34 #ifdef AUDIO_ENABLE
  35   bool music_activated = false;
  36
  37   // music sequencer
  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;
  43
  44   static uint16_t music_sequence_timer = 0;
  45   static uint16_t music_sequence_interval = 100;
  46
  47 #endif
  48
  49 #ifdef MIDI_ENABLE
  50   bool midi_activated = false;
  51 #endif
  52
  53 // Leader key stuff
  54 bool leading = false;
  55 uint16_t leader_time = 0;
  56
  57 uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
  58 uint8_t leader_sequence_size = 0;
  59
  60 // Chording stuff
  61 #define CHORDING_MAX 4
  62 bool chording = false;
  63
  64 uint8_t chord_keys[CHORDING_MAX] = {0};
  65 uint8_t chord_key_count = 0;
  66 uint8_t chord_key_down = 0;
  67
  68 #ifdef UNICODE_ENABLE
  69   static uint8_t input_mode;
  70 #endif
  71
  72 // Shift / paren setup
  73
  74 #ifndef LSPO_KEY
  75   #define LSPO_KEY KC_9
  76 #endif
  77 #ifndef RSPC_KEY
  78   #define RSPC_KEY KC_0
  79 #endif
  80
  81 static bool shift_interrupted[2] = {0, 0};
  82
  83 bool keys_chord(uint8_t keys[]) {
  84   uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
  85   bool pass = true;
  86   uint8_t in = 0;
  87   for (uint8_t i = 0; i < chord_key_count; i++) {
  88     bool found = false;
  89     for (uint8_t j = 0; j < keys_size; j++) {
  90       if (chord_keys[i] == (keys[j] & 0xFF)) {
  91         in++; // detects key in chord
  92         found = true;
  93         break;
  94       }
  95     }
  96     if (found)
  97       continue;
  98     if (chord_keys[i] != 0)  {
  99       pass = false; // makes sure rest are blank
 100     }
 101   }
 102   return (pass && (in == keys_size));
 103 }
 104
 105 #ifdef UNICODE_ENABLE
 106
 107 uint16_t hex_to_keycode(uint8_t hex)
 108 {
 109   if (hex == 0x0) {
 110     return KC_0;
 111   } else if (hex < 0xA) {
 112     return KC_1 + (hex - 0x1);
 113   } else {
 114     return KC_A + (hex - 0xA);
 115   }
 116 }
 117
 118 void set_unicode_mode(uint8_t os_target)
 119 {
 120   input_mode = os_target;
 121 }
 122
 123 #endif
 124
 125 bool process_record_quantum(keyrecord_t *record) {
 126
 127   /* This gets the keycode from the key pressed */
 128   keypos_t key = record->event.key;
 129   uint16_t keycode;
 130
 131   #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
 132     uint8_t layer;
 133
 134     if (record->event.pressed) {
 135       layer = layer_switch_get_layer(key);
 136       update_source_layers_cache(key, layer);
 137     } else {
 138       layer = read_source_layers_cache(key);
 139     }
 140     keycode = keymap_key_to_keycode(layer, key);
 141   #else
 142     keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
 143   #endif
 144
 145   if (!process_record_kb(keycode, record))
 146     return false;
 147
 148     // This is how you use actions here
 149     // if (keycode == KC_LEAD) {
 150     //   action_t action;
 151     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
 152     //   process_action(record, action);
 153     //   return false;
 154     // }
 155
 156   #ifdef MIDI_ENABLE
 157     if (keycode == MI_ON && record->event.pressed) {
 158       midi_activated = true;
 159       music_scale_user();
 160       return false;
 161     }
 162
 163     if (keycode == MI_OFF && record->event.pressed) {
 164       midi_activated = false;
 165       midi_send_cc(&midi_device, 0, 0x7B, 0);
 166       return false;
 167     }
 168
 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);
 174           }
 175           return false;
 176       }
 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);
 181           }
 182           return false;
 183       }
 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);
 187           return false;
 188       }
 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);
 192           return false;
 193       }
 194       // basic
 195       // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
 196       // advanced
 197       // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
 198       // guitar
 199       uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
 200       // violin
 201       // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
 202
 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);
 206       } else {
 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);
 209       }
 210
 211       if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
 212         return false;
 213     }
 214   #endif
 215
 216   #ifdef AUDIO_ENABLE
 217     if (keycode == AU_ON && record->event.pressed) {
 218       audio_on();
 219       return false;
 220     }
 221
 222     if (keycode == AU_OFF && record->event.pressed) {
 223       audio_off();
 224       return false;
 225     }
 226
 227     if (keycode == AU_TOG && record->event.pressed) {
 228         if (is_audio_on())
 229         {
 230             audio_off();
 231         }
 232         else
 233         {
 234             audio_on();
 235         }
 236       return false;
 237     }
 238
 239     if (keycode == MU_ON && record->event.pressed) {
 240         music_on();
 241         return false;
 242     }
 243
 244     if (keycode == MU_OFF && record->event.pressed) {
 245         music_off();
 246         return false;
 247     }
 248
 249     if (keycode == MU_TOG && record->event.pressed) {
 250         if (music_activated)
 251         {
 252             music_off();
 253         }
 254         else
 255         {
 256             music_on();
 257         }
 258         return false;
 259     }
 260
 261     if (keycode == MUV_IN && record->event.pressed) {
 262         voice_iterate();
 263         music_scale_user();
 264         return false;
 265     }
 266
 267     if (keycode == MUV_DE && record->event.pressed) {
 268         voice_deiterate();
 269         music_scale_user();
 270         return false;
 271     }
 272
 273     if (music_activated) {
 274
 275       if (keycode == KC_LCTL && record->event.pressed) { // Start recording
 276         stop_all_notes();
 277         music_sequence_recording = true;
 278         music_sequence_playing = false;
 279         music_sequence_count = 0;
 280         return false;
 281       }
 282
 283       if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
 284         stop_all_notes();
 285         music_sequence_recording = false;
 286         music_sequence_playing = false;
 287         return false;
 288       }
 289
 290       if (keycode == KC_LGUI && record->event.pressed) { // Start playing
 291         stop_all_notes();
 292         music_sequence_recording = false;
 293         music_sequence_playing = true;
 294         music_sequence_position = 0;
 295         music_sequence_timer = 0;
 296         return false;
 297       }
 298
 299       if (keycode == KC_UP) {
 300         if (record->event.pressed)
 301             music_sequence_interval-=10;
 302         return false;
 303       }
 304
 305       if (keycode == KC_DOWN) {
 306         if (record->event.pressed)
 307             music_sequence_interval+=10;
 308         return false;
 309       }
 310
 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++;
 317         }
 318       } else {
 319         stop_note(freq);
 320       }
 321
 322       if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
 323         return false;
 324     }
 325   #endif
 326
 327 #ifndef DISABLE_LEADER
 328   // Leader key set-up
 329   if (record->event.pressed) {
 330     if (!leading && keycode == KC_LEAD) {
 331       leader_start();
 332       leading = true;
 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;
 338       leader_sequence[3] = 0;
 339       leader_sequence[4] = 0;
 340       return false;
 341     }
 342     if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
 343       leader_sequence[leader_sequence_size] = keycode;
 344       leader_sequence_size++;
 345       return false;
 346     }
 347   }
 348 #endif
 349
 350 #define DISABLE_CHORDING
 351 #ifndef DISABLE_CHORDING
 352
 353   if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
 354     if (record->event.pressed) {
 355       if (!chording) {
 356         chording = true;
 357         for (uint8_t i = 0; i < CHORDING_MAX; i++)
 358           chord_keys[i] = 0;
 359         chord_key_count = 0;
 360         chord_key_down = 0;
 361       }
 362       chord_keys[chord_key_count] = (keycode & 0xFF);
 363       chord_key_count++;
 364       chord_key_down++;
 365       return false;
 366     } else {
 367       if (chording) {
 368         chord_key_down--;
 369         if (chord_key_down == 0) {
 370           chording = false;
 371           // Chord Dictionary
 372           if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
 373             register_code(KC_A);
 374             unregister_code(KC_A);
 375             return false;
 376           }
 377           for (uint8_t i = 0; i < chord_key_count; i++) {
 378             register_code(chord_keys[i]);
 379             unregister_code(chord_keys[i]);
 380             return false;
 381           }
 382         }
 383       }
 384     }
 385   }
 386
 387 #endif
 388
 389 #ifdef UNICODE_ENABLE
 390
 391   if (keycode > QK_UNICODE && record->event.pressed) {
 392     uint16_t unicode = keycode & 0x7FFF;
 393     switch(input_mode) {
 394       case UC_OSX:
 395         register_code(KC_LALT);
 396         break;
 397       case UC_LNX:
 398         register_code(KC_LCTL);
 399         register_code(KC_LSFT);
 400         register_code(KC_U);
 401         unregister_code(KC_U);
 402         break;
 403       case UC_WIN:
 404         register_code(KC_LALT);
 405         register_code(KC_PPLS);
 406         unregister_code(KC_PPLS);
 407         break;
 408     }
 409     for(int i = 3; i >= 0; i--) {
 410         uint8_t digit = ((unicode >> (i*4)) & 0xF);
 411         register_code(hex_to_keycode(digit));
 412         unregister_code(hex_to_keycode(digit));
 413     }
 414     switch(input_mode) {
 415       case UC_OSX:
 416       case UC_WIN:
 417         unregister_code(KC_LALT);
 418         break;
 419       case UC_LNX:
 420         unregister_code(KC_LCTL);
 421         unregister_code(KC_LSFT);
 422         break;
 423     }
 424   }
 425
 426 #endif
 427
 428   // Shift / paren setup
 429
 430   switch(keycode) {
 431     case RESET:
 432       if (record->event.pressed) {
 433         clear_keyboard();
 434         #ifdef AUDIO_ENABLE
 435           stop_all_notes();
 436           shutdown_user();
 437         #endif
 438         _delay_ms(250);
 439         #ifdef ATREUS_ASTAR
 440             *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
 441         #endif
 442         bootloader_jump();
 443         return false;
 444       }
 445       break;
 446     case DEBUG:
 447       if (record->event.pressed) {
 448           print("\nDEBUG: enabled.\n");
 449           debug_enable = true;
 450           return false;
 451       }
 452       break;
 453     case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI:
 454       if (record->event.pressed) {
 455         // MAGIC actions (BOOTMAGIC without the boot)
 456         if (!eeconfig_is_enabled()) {
 457             eeconfig_init();
 458         }
 459         /* keymap config */
 460         keymap_config.raw = eeconfig_read_keymap();
 461         if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) {
 462             keymap_config.swap_control_capslock = 1;
 463         } else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) {
 464             keymap_config.capslock_to_control = 1;
 465         } else if (keycode == MAGIC_SWAP_LALT_LGUI) {
 466             keymap_config.swap_lalt_lgui = 1;
 467         } else if (keycode == MAGIC_SWAP_RALT_RGUI) {
 468             keymap_config.swap_ralt_rgui = 1;
 469         } else if (keycode == MAGIC_NO_GUI) {
 470             keymap_config.no_gui = 1;
 471         } else if (keycode == MAGIC_SWAP_GRAVE_ESC) {
 472             keymap_config.swap_grave_esc = 1;
 473         } else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) {
 474             keymap_config.swap_backslash_backspace = 1;
 475         } else if (keycode == MAGIC_HOST_NKRO) {
 476             keymap_config.nkro = 1;
 477         } else if (keycode == MAGIC_SWAP_ALT_GUI) {
 478             keymap_config.swap_lalt_lgui = 1;
 479             keymap_config.swap_ralt_rgui = 1;
 480         }
 481         /* UNs */
 482         else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) {
 483             keymap_config.swap_control_capslock = 0;
 484         } else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) {
 485             keymap_config.capslock_to_control = 0;
 486         } else if (keycode == MAGIC_UNSWAP_LALT_LGUI) {
 487             keymap_config.swap_lalt_lgui = 0;
 488         } else if (keycode == MAGIC_UNSWAP_RALT_RGUI) {
 489             keymap_config.swap_ralt_rgui = 0;
 490         } else if (keycode == MAGIC_UNNO_GUI) {
 491             keymap_config.no_gui = 0;
 492         } else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) {
 493             keymap_config.swap_grave_esc = 0;
 494         } else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) {
 495             keymap_config.swap_backslash_backspace = 0;
 496         } else if (keycode == MAGIC_UNHOST_NKRO) {
 497             keymap_config.nkro = 0;
 498         } else if (keycode == MAGIC_UNSWAP_ALT_GUI) {
 499             keymap_config.swap_lalt_lgui = 0;
 500             keymap_config.swap_ralt_rgui = 0;
 501         }
 502         eeconfig_update_keymap(keymap_config.raw);
 503         return false;
 504       }
 505       break;
 506     case KC_LSPO: {
 507       if (record->event.pressed) {
 508         shift_interrupted[0] = false;
 509         register_mods(MOD_BIT(KC_LSFT));
 510       }
 511       else {
 512         if (!shift_interrupted[0]) {
 513           register_code(LSPO_KEY);
 514           unregister_code(LSPO_KEY);
 515         }
 516         unregister_mods(MOD_BIT(KC_LSFT));
 517       }
 518       return false;
 519       break;
 520     }
 521
 522     case KC_RSPC: {
 523       if (record->event.pressed) {
 524         shift_interrupted[1] = false;
 525         register_mods(MOD_BIT(KC_RSFT));
 526       }
 527       else {
 528         if (!shift_interrupted[1]) {
 529           register_code(RSPC_KEY);
 530           unregister_code(RSPC_KEY);
 531         }
 532         unregister_mods(MOD_BIT(KC_RSFT));
 533       }
 534       return false;
 535       break;
 536     }
 537     default: {
 538       shift_interrupted[0] = true;
 539       shift_interrupted[1] = true;
 540       break;
 541     }
 542   }
 543
 544   return process_action_kb(record);
 545 }
 546
 547 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
 548     0, 0, 0, 0, 0, 0, 0, 0,
 549     0, 0, 0, 0, 0, 0, 0, 0,
 550     0, 0, 0, 0, 0, 0, 0, 0,
 551     0, 0, 0, 0, 0, 0, 0, 0,
 552     0, 1, 1, 1, 1, 1, 1, 0,
 553     1, 1, 1, 1, 0, 0, 0, 0,
 554     0, 0, 0, 0, 0, 0, 0, 0,
 555     0, 0, 1, 0, 1, 0, 1, 1,
 556     1, 1, 1, 1, 1, 1, 1, 1,
 557     1, 1, 1, 1, 1, 1, 1, 1,
 558     1, 1, 1, 1, 1, 1, 1, 1,
 559     1, 1, 1, 0, 0, 0, 1, 1,
 560     0, 0, 0, 0, 0, 0, 0, 0,
 561     0, 0, 0, 0, 0, 0, 0, 0,
 562     0, 0, 0, 0, 0, 0, 0, 0,
 563     0, 0, 0, 1, 1, 1, 1, 0
 564 };
 565
 566 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
 567     0, 0, 0, 0, 0, 0, 0, 0,
 568     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 569     0, 0, 0, 0, 0, 0, 0, 0,
 570     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 571     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 572     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 573     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 574     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 575     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 576     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 577     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 578     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 579     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 580     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 581     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 582     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 583 };
 584
 585 /* for users whose OSes are set to Colemak */
 586 #if 0
 587 #include "keymap_colemak.h"
 588
 589 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
 590     0, 0, 0, 0, 0, 0, 0, 0,
 591     0, 0, 0, 0, 0, 0, 0, 0,
 592     0, 0, 0, 0, 0, 0, 0, 0,
 593     0, 0, 0, 0, 0, 0, 0, 0,
 594     0, 1, 1, 1, 1, 1, 1, 0,
 595     1, 1, 1, 1, 0, 0, 0, 0,
 596     0, 0, 0, 0, 0, 0, 0, 0,
 597     0, 0, 1, 0, 1, 0, 1, 1,
 598     1, 1, 1, 1, 1, 1, 1, 1,
 599     1, 1, 1, 1, 1, 1, 1, 1,
 600     1, 1, 1, 1, 1, 1, 1, 1,
 601     1, 1, 1, 0, 0, 0, 1, 1,
 602     0, 0, 0, 0, 0, 0, 0, 0,
 603     0, 0, 0, 0, 0, 0, 0, 0,
 604     0, 0, 0, 0, 0, 0, 0, 0,
 605     0, 0, 0, 1, 1, 1, 1, 0
 606 };
 607
 608 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
 609     0, 0, 0, 0, 0, 0, 0, 0,
 610     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 611     0, 0, 0, 0, 0, 0, 0, 0,
 612     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 613     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 614     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 615     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 616     KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 617     KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
 618     CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
 619     CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
 620     CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 621     KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
 622     CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
 623     CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
 624     CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 625 };
 626
 627 #endif
 628
 629 void send_string(const char *str) {
 630     while (1) {
 631         uint8_t keycode;
 632         uint8_t ascii_code = pgm_read_byte(str);
 633         if (!ascii_code) break;
 634         keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
 635         if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
 636             register_code(KC_LSFT);
 637             register_code(keycode);
 638             unregister_code(keycode);
 639             unregister_code(KC_LSFT);
 640         }
 641         else {
 642             register_code(keycode);
 643             unregister_code(keycode);
 644         }
 645         ++str;
 646     }
 647 }
 648
 649 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 650   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
 651     layer_on(layer3);
 652   } else {
 653     layer_off(layer3);
 654   }
 655 }
 656
 657 void matrix_init_quantum() {
 658   matrix_init_kb();
 659 }
 660
 661 void matrix_scan_quantum() {
 662   #ifdef AUDIO_ENABLE
 663   if (music_sequence_playing) {
 664     if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
 665       music_sequence_timer = timer_read();
 666       stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
 667       play_note(music_sequence[music_sequence_position], 0xF);
 668       music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
 669     }
 670   }
 671
 672   #endif
 673
 674   matrix_scan_kb();
 675 }
 676 #ifdef AUDIO_ENABLE
 677   bool is_music_on(void) {
 678       return (music_activated != 0);
 679   }
 680
 681   void music_toggle(void) {
 682       if (!music_activated) {
 683           music_on();
 684       } else {
 685           music_off();
 686       }
 687   }
 688
 689   void music_on(void) {
 690       music_activated = 1;
 691       music_on_user();
 692   }
 693
 694   void music_off(void) {
 695       music_activated = 0;
 696       stop_all_notes();
 697   }
 698
 699 #endif
 700
 701 //------------------------------------------------------------------------------
 702 // Override these functions in your keymap file to play different tunes on
 703 // different events such as startup and bootloader jump
 704
 705 __attribute__ ((weak))
 706 void startup_user() {}
 707
 708 __attribute__ ((weak))
 709 void shutdown_user() {}
 710
 711 __attribute__ ((weak))
 712 void music_on_user() {}
 713
 714 __attribute__ ((weak))
 715 void audio_on_user() {}
 716
 717 __attribute__ ((weak))
 718 void music_scale_user() {}
 719
 720 //------------------------------------------------------------------------------