quantum/quantum.c

   1 /* Copyright 2016-2017 Jack Humbert
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include "quantum.h"
  18 #ifdef PROTOCOL_LUFA
  19 #include "outputselect.h"
  20 #endif
  21
  22 #ifndef TAPPING_TERM
  23 #define TAPPING_TERM 200
  24 #endif
  25
  26 #ifndef BREATHING_PERIOD
  27 #define BREATHING_PERIOD 6
  28 #endif
  29
  30 #include "backlight.h"
  31 extern backlight_config_t backlight_config;
  32
  33 #ifdef FAUXCLICKY_ENABLE
  34 #include "fauxclicky.h"
  35 #endif
  36
  37 #ifdef API_ENABLE
  38 #include "api.h"
  39 #endif
  40
  41 #ifdef MIDI_ENABLE
  42 #include "process_midi.h"
  43 #endif
  44
  45 #ifdef AUDIO_ENABLE
  46   #ifndef GOODBYE_SONG
  47     #define GOODBYE_SONG SONG(GOODBYE_SOUND)
  48   #endif
  49   #ifndef AG_NORM_SONG
  50     #define AG_NORM_SONG SONG(AG_NORM_SOUND)
  51   #endif
  52   #ifndef AG_SWAP_SONG
  53     #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
  54   #endif
  55   float goodbye_song[][2] = GOODBYE_SONG;
  56   float ag_norm_song[][2] = AG_NORM_SONG;
  57   float ag_swap_song[][2] = AG_SWAP_SONG;
  58   #ifdef DEFAULT_LAYER_SONGS
  59     float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
  60   #endif
  61 #endif
  62
  63 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
  64   switch (code) {
  65   case QK_MODS ... QK_MODS_MAX:
  66     break;
  67   default:
  68     return;
  69   }
  70
  71   if (code & QK_LCTL)
  72     f(KC_LCTL);
  73   if (code & QK_LSFT)
  74     f(KC_LSFT);
  75   if (code & QK_LALT)
  76     f(KC_LALT);
  77   if (code & QK_LGUI)
  78     f(KC_LGUI);
  79
  80   if (code < QK_RMODS_MIN) return;
  81
  82   if (code & QK_RCTL)
  83     f(KC_RCTL);
  84   if (code & QK_RSFT)
  85     f(KC_RSFT);
  86   if (code & QK_RALT)
  87     f(KC_RALT);
  88   if (code & QK_RGUI)
  89     f(KC_RGUI);
  90 }
  91
  92 static inline void qk_register_weak_mods(uint8_t kc) {
  93     add_weak_mods(MOD_BIT(kc));
  94     send_keyboard_report();
  95 }
  96
  97 static inline void qk_unregister_weak_mods(uint8_t kc) {
  98     del_weak_mods(MOD_BIT(kc));
  99     send_keyboard_report();
 100 }
 101
 102 static inline void qk_register_mods(uint8_t kc) {
 103     add_weak_mods(MOD_BIT(kc));
 104     send_keyboard_report();
 105 }
 106
 107 static inline void qk_unregister_mods(uint8_t kc) {
 108     del_weak_mods(MOD_BIT(kc));
 109     send_keyboard_report();
 110 }
 111
 112 void register_code16 (uint16_t code) {
 113   if (IS_MOD(code) || code == KC_NO) {
 114       do_code16 (code, qk_register_mods);
 115   } else {
 116       do_code16 (code, qk_register_weak_mods);
 117   }
 118   register_code (code);
 119 }
 120
 121 void unregister_code16 (uint16_t code) {
 122   unregister_code (code);
 123   if (IS_MOD(code) || code == KC_NO) {
 124       do_code16 (code, qk_unregister_mods);
 125   } else {
 126       do_code16 (code, qk_unregister_weak_mods);
 127   }
 128 }
 129
 130 __attribute__ ((weak))
 131 bool process_action_kb(keyrecord_t *record) {
 132   return true;
 133 }
 134
 135 __attribute__ ((weak))
 136 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
 137   return process_record_user(keycode, record);
 138 }
 139
 140 __attribute__ ((weak))
 141 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 142   return true;
 143 }
 144
 145 void reset_keyboard(void) {
 146   clear_keyboard();
 147 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
 148   process_midi_all_notes_off();
 149 #endif
 150 #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
 151   music_all_notes_off();
 152   uint16_t timer_start = timer_read();
 153   PLAY_SONG(goodbye_song);
 154   shutdown_user();
 155   while(timer_elapsed(timer_start) < 250)
 156     wait_ms(1);
 157   stop_all_notes();
 158 #else
 159   wait_ms(250);
 160 #endif
 161 // this is also done later in bootloader.c - not sure if it's neccesary here
 162 #ifdef BOOTLOADER_CATERINA
 163   *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
 164 #endif
 165   bootloader_jump();
 166 }
 167
 168 // Shift / paren setup
 169
 170 #ifndef LSPO_KEY
 171   #define LSPO_KEY KC_9
 172 #endif
 173 #ifndef RSPC_KEY
 174   #define RSPC_KEY KC_0
 175 #endif
 176
 177 // Shift / Enter setup
 178 #ifndef SFTENT_KEY
 179   #define SFTENT_KEY KC_ENT
 180 #endif
 181
 182 static bool shift_interrupted[2] = {0, 0};
 183 static uint16_t scs_timer[2] = {0, 0};
 184
 185 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
 186  * Used to ensure that the correct keycode is released if the key is released.
 187  */
 188 static bool grave_esc_was_shifted = false;
 189
 190 bool process_record_quantum(keyrecord_t *record) {
 191
 192   /* This gets the keycode from the key pressed */
 193   keypos_t key = record->event.key;
 194   uint16_t keycode;
 195
 196   #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
 197     /* TODO: Use store_or_get_action() or a similar function. */
 198     if (!disable_action_cache) {
 199       uint8_t layer;
 200
 201       if (record->event.pressed) {
 202         layer = layer_switch_get_layer(key);
 203         update_source_layers_cache(key, layer);
 204       } else {
 205         layer = read_source_layers_cache(key);
 206       }
 207       keycode = keymap_key_to_keycode(layer, key);
 208     } else
 209   #endif
 210     keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
 211
 212     // This is how you use actions here
 213     // if (keycode == KC_LEAD) {
 214     //   action_t action;
 215     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
 216     //   process_action(record, action);
 217     //   return false;
 218     // }
 219
 220   #ifdef TAP_DANCE_ENABLE
 221     preprocess_tap_dance(keycode, record);
 222   #endif
 223
 224   if (!(
 225   #if defined(KEY_LOCK_ENABLE)
 226     // Must run first to be able to mask key_up events.
 227     process_key_lock(&keycode, record) &&
 228   #endif
 229   #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
 230       process_clicky(keycode, record) &&
 231   #endif //AUDIO_CLICKY
 232     process_record_kb(keycode, record) &&
 233   #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
 234     process_rgb_matrix(keycode, record) &&
 235   #endif
 236   #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
 237     process_midi(keycode, record) &&
 238   #endif
 239   #ifdef AUDIO_ENABLE
 240     process_audio(keycode, record) &&
 241   #endif
 242   #ifdef STENO_ENABLE
 243     process_steno(keycode, record) &&
 244   #endif
 245   #if ( defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
 246     process_music(keycode, record) &&
 247   #endif
 248   #ifdef TAP_DANCE_ENABLE
 249     process_tap_dance(keycode, record) &&
 250   #endif
 251   #ifndef DISABLE_LEADER
 252     process_leader(keycode, record) &&
 253   #endif
 254   #ifndef DISABLE_CHORDING
 255     process_chording(keycode, record) &&
 256   #endif
 257   #ifdef COMBO_ENABLE
 258     process_combo(keycode, record) &&
 259   #endif
 260   #ifdef UNICODE_ENABLE
 261     process_unicode(keycode, record) &&
 262   #endif
 263   #ifdef UCIS_ENABLE
 264     process_ucis(keycode, record) &&
 265   #endif
 266   #ifdef PRINTING_ENABLE
 267     process_printer(keycode, record) &&
 268   #endif
 269   #ifdef AUTO_SHIFT_ENABLE
 270     process_auto_shift(keycode, record) &&
 271   #endif
 272   #ifdef UNICODEMAP_ENABLE
 273     process_unicode_map(keycode, record) &&
 274   #endif
 275   #ifdef TERMINAL_ENABLE
 276     process_terminal(keycode, record) &&
 277   #endif
 278       true)) {
 279     return false;
 280   }
 281
 282   // Shift / paren setup
 283
 284   switch(keycode) {
 285     case RESET:
 286       if (record->event.pressed) {
 287         reset_keyboard();
 288       }
 289     return false;
 290     case DEBUG:
 291       if (record->event.pressed) {
 292           debug_enable = true;
 293           print("DEBUG: enabled.\n");
 294       }
 295     return false;
 296   #ifdef FAUXCLICKY_ENABLE
 297   case FC_TOG:
 298     if (record->event.pressed) {
 299       FAUXCLICKY_TOGGLE;
 300     }
 301     return false;
 302   case FC_ON:
 303     if (record->event.pressed) {
 304       FAUXCLICKY_ON;
 305     }
 306     return false;
 307   case FC_OFF:
 308     if (record->event.pressed) {
 309       FAUXCLICKY_OFF;
 310     }
 311     return false;
 312   #endif
 313   #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 314   case RGB_TOG:
 315     if (record->event.pressed) {
 316       rgblight_toggle();
 317     }
 318     return false;
 319   case RGB_MODE_FORWARD:
 320     if (record->event.pressed) {
 321       uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
 322       if(shifted) {
 323         rgblight_step_reverse();
 324       }
 325       else {
 326         rgblight_step();
 327       }
 328     }
 329     return false;
 330   case RGB_MODE_REVERSE:
 331     if (record->event.pressed) {
 332       uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
 333       if(shifted) {
 334         rgblight_step();
 335       }
 336       else {
 337         rgblight_step_reverse();
 338       }
 339     }
 340     return false;
 341   case RGB_SMOD:
 342     // same as RBG_MOD, but if shift is pressed, it will use the reverese direction instead.
 343     if (record->event.pressed) {
 344       uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
 345       if(shifted) {
 346         rgblight_step_reverse();
 347       }
 348       else {
 349         rgblight_step();
 350       }
 351     }
 352     return false;
 353   case RGB_HUI:
 354     if (record->event.pressed) {
 355       rgblight_increase_hue();
 356     }
 357     return false;
 358   case RGB_HUD:
 359     if (record->event.pressed) {
 360       rgblight_decrease_hue();
 361     }
 362     return false;
 363   case RGB_SAI:
 364     if (record->event.pressed) {
 365       rgblight_increase_sat();
 366     }
 367     return false;
 368   case RGB_SAD:
 369     if (record->event.pressed) {
 370       rgblight_decrease_sat();
 371     }
 372     return false;
 373   case RGB_VAI:
 374     if (record->event.pressed) {
 375       rgblight_increase_val();
 376     }
 377     return false;
 378   case RGB_VAD:
 379     if (record->event.pressed) {
 380       rgblight_decrease_val();
 381     }
 382     return false;
 383   case RGB_SPI:
 384     if (record->event.pressed) {
 385       rgblight_increase_speed();
 386     }
 387     return false;
 388   case RGB_SPD:
 389     if (record->event.pressed) {
 390       rgblight_decrease_speed();
 391     }
 392     return false;
 393   case RGB_MODE_PLAIN:
 394     if (record->event.pressed) {
 395       rgblight_mode(1);
 396     }
 397     return false;
 398   case RGB_MODE_BREATHE:
 399     if (record->event.pressed) {
 400       if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
 401         rgblight_step();
 402       } else {
 403         rgblight_mode(2);
 404       }
 405     }
 406     return false;
 407   case RGB_MODE_RAINBOW:
 408     if (record->event.pressed) {
 409       if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
 410         rgblight_step();
 411       } else {
 412         rgblight_mode(6);
 413       }
 414     }
 415     return false;
 416   case RGB_MODE_SWIRL:
 417     if (record->event.pressed) {
 418       if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
 419         rgblight_step();
 420       } else {
 421         rgblight_mode(9);
 422       }
 423     }
 424     return false;
 425   case RGB_MODE_SNAKE:
 426     if (record->event.pressed) {
 427       if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
 428         rgblight_step();
 429       } else {
 430         rgblight_mode(15);
 431       }
 432     }
 433     return false;
 434   case RGB_MODE_KNIGHT:
 435     if (record->event.pressed) {
 436       if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
 437         rgblight_step();
 438       } else {
 439         rgblight_mode(21);
 440       }
 441     }
 442     return false;
 443   case RGB_MODE_XMAS:
 444     if (record->event.pressed) {
 445       rgblight_mode(24);
 446     }
 447     return false;
 448   case RGB_MODE_GRADIENT:
 449     if (record->event.pressed) {
 450       if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
 451         rgblight_step();
 452       } else {
 453         rgblight_mode(25);
 454       }
 455     }
 456     return false;
 457   case RGB_MODE_RGBTEST:
 458     if (record->event.pressed) {
 459       rgblight_mode(35);
 460     }
 461     return false;
 462   #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 463     #ifdef PROTOCOL_LUFA
 464     case OUT_AUTO:
 465       if (record->event.pressed) {
 466         set_output(OUTPUT_AUTO);
 467       }
 468       return false;
 469     case OUT_USB:
 470       if (record->event.pressed) {
 471         set_output(OUTPUT_USB);
 472       }
 473       return false;
 474     #ifdef BLUETOOTH_ENABLE
 475     case OUT_BT:
 476       if (record->event.pressed) {
 477         set_output(OUTPUT_BLUETOOTH);
 478       }
 479       return false;
 480     #endif
 481     #endif
 482     case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
 483       if (record->event.pressed) {
 484         // MAGIC actions (BOOTMAGIC without the boot)
 485         if (!eeconfig_is_enabled()) {
 486             eeconfig_init();
 487         }
 488         /* keymap config */
 489         keymap_config.raw = eeconfig_read_keymap();
 490         switch (keycode)
 491         {
 492           case MAGIC_SWAP_CONTROL_CAPSLOCK:
 493             keymap_config.swap_control_capslock = true;
 494             break;
 495           case MAGIC_CAPSLOCK_TO_CONTROL:
 496             keymap_config.capslock_to_control = true;
 497             break;
 498           case MAGIC_SWAP_LALT_LGUI:
 499             keymap_config.swap_lalt_lgui = true;
 500             break;
 501           case MAGIC_SWAP_RALT_RGUI:
 502             keymap_config.swap_ralt_rgui = true;
 503             break;
 504           case MAGIC_NO_GUI:
 505             keymap_config.no_gui = true;
 506             break;
 507           case MAGIC_SWAP_GRAVE_ESC:
 508             keymap_config.swap_grave_esc = true;
 509             break;
 510           case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 511             keymap_config.swap_backslash_backspace = true;
 512             break;
 513           case MAGIC_HOST_NKRO:
 514             keymap_config.nkro = true;
 515             break;
 516           case MAGIC_SWAP_ALT_GUI:
 517             keymap_config.swap_lalt_lgui = true;
 518             keymap_config.swap_ralt_rgui = true;
 519             #ifdef AUDIO_ENABLE
 520               PLAY_SONG(ag_swap_song);
 521             #endif
 522             break;
 523           case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 524             keymap_config.swap_control_capslock = false;
 525             break;
 526           case MAGIC_UNCAPSLOCK_TO_CONTROL:
 527             keymap_config.capslock_to_control = false;
 528             break;
 529           case MAGIC_UNSWAP_LALT_LGUI:
 530             keymap_config.swap_lalt_lgui = false;
 531             break;
 532           case MAGIC_UNSWAP_RALT_RGUI:
 533             keymap_config.swap_ralt_rgui = false;
 534             break;
 535           case MAGIC_UNNO_GUI:
 536             keymap_config.no_gui = false;
 537             break;
 538           case MAGIC_UNSWAP_GRAVE_ESC:
 539             keymap_config.swap_grave_esc = false;
 540             break;
 541           case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 542             keymap_config.swap_backslash_backspace = false;
 543             break;
 544           case MAGIC_UNHOST_NKRO:
 545             keymap_config.nkro = false;
 546             break;
 547           case MAGIC_UNSWAP_ALT_GUI:
 548             keymap_config.swap_lalt_lgui = false;
 549             keymap_config.swap_ralt_rgui = false;
 550             #ifdef AUDIO_ENABLE
 551               PLAY_SONG(ag_norm_song);
 552             #endif
 553             break;
 554           case MAGIC_TOGGLE_NKRO:
 555             keymap_config.nkro = !keymap_config.nkro;
 556             break;
 557           default:
 558             break;
 559         }
 560         eeconfig_update_keymap(keymap_config.raw);
 561         clear_keyboard(); // clear to prevent stuck keys
 562
 563         return false;
 564       }
 565       break;
 566     case KC_LSPO: {
 567       if (record->event.pressed) {
 568         shift_interrupted[0] = false;
 569         scs_timer[0] = timer_read ();
 570         register_mods(MOD_BIT(KC_LSFT));
 571       }
 572       else {
 573         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 574           if (get_mods() & MOD_BIT(KC_RSFT)) {
 575             shift_interrupted[0] = true;
 576             shift_interrupted[1] = true;
 577           }
 578         #endif
 579         if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
 580           register_code(LSPO_KEY);
 581           unregister_code(LSPO_KEY);
 582         }
 583         unregister_mods(MOD_BIT(KC_LSFT));
 584       }
 585       return false;
 586     }
 587
 588     case KC_RSPC: {
 589       if (record->event.pressed) {
 590         shift_interrupted[1] = false;
 591         scs_timer[1] = timer_read ();
 592         register_mods(MOD_BIT(KC_RSFT));
 593       }
 594       else {
 595         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 596           if (get_mods() & MOD_BIT(KC_LSFT)) {
 597             shift_interrupted[0] = true;
 598             shift_interrupted[1] = true;
 599           }
 600         #endif
 601         if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 602           register_code(RSPC_KEY);
 603           unregister_code(RSPC_KEY);
 604         }
 605         unregister_mods(MOD_BIT(KC_RSFT));
 606       }
 607       return false;
 608     }
 609
 610     case KC_SFTENT: {
 611       if (record->event.pressed) {
 612         shift_interrupted[1] = false;
 613         scs_timer[1] = timer_read ();
 614         register_mods(MOD_BIT(KC_RSFT));
 615       }
 616       else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 617         unregister_mods(MOD_BIT(KC_RSFT));
 618         register_code(SFTENT_KEY);
 619         unregister_code(SFTENT_KEY);
 620       }
 621       else {
 622         unregister_mods(MOD_BIT(KC_RSFT));
 623       }
 624       return false;
 625     }
 626
 627     case GRAVE_ESC: {
 628       uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
 629                                       |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
 630
 631 #ifdef GRAVE_ESC_ALT_OVERRIDE
 632       // if ALT is pressed, ESC is always sent
 633       // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 634       if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 635         shifted = 0;
 636       }
 637 #endif
 638
 639 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 640       // if CTRL is pressed, ESC is always sent
 641       // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 642       if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 643         shifted = 0;
 644       }
 645 #endif
 646
 647 #ifdef GRAVE_ESC_GUI_OVERRIDE
 648       // if GUI is pressed, ESC is always sent
 649       if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 650         shifted = 0;
 651       }
 652 #endif
 653
 654 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 655       // if SHIFT is pressed, ESC is always sent
 656       if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 657         shifted = 0;
 658       }
 659 #endif
 660
 661       if (record->event.pressed) {
 662         grave_esc_was_shifted = shifted;
 663         add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 664       }
 665       else {
 666         del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 667       }
 668
 669       send_keyboard_report();
 670       return false;
 671     }
 672
 673 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
 674     case BL_BRTG: {
 675       if (record->event.pressed)
 676         breathing_toggle();
 677       return false;
 678     }
 679 #endif
 680
 681     default: {
 682       shift_interrupted[0] = true;
 683       shift_interrupted[1] = true;
 684       break;
 685     }
 686   }
 687
 688   return process_action_kb(record);
 689 }
 690
 691 __attribute__ ((weak))
 692 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 693     0, 0, 0, 0, 0, 0, 0, 0,
 694     0, 0, 0, 0, 0, 0, 0, 0,
 695     0, 0, 0, 0, 0, 0, 0, 0,
 696     0, 0, 0, 0, 0, 0, 0, 0,
 697     0, 1, 1, 1, 1, 1, 1, 0,
 698     1, 1, 1, 1, 0, 0, 0, 0,
 699     0, 0, 0, 0, 0, 0, 0, 0,
 700     0, 0, 1, 0, 1, 0, 1, 1,
 701     1, 1, 1, 1, 1, 1, 1, 1,
 702     1, 1, 1, 1, 1, 1, 1, 1,
 703     1, 1, 1, 1, 1, 1, 1, 1,
 704     1, 1, 1, 0, 0, 0, 1, 1,
 705     0, 0, 0, 0, 0, 0, 0, 0,
 706     0, 0, 0, 0, 0, 0, 0, 0,
 707     0, 0, 0, 0, 0, 0, 0, 0,
 708     0, 0, 0, 1, 1, 1, 1, 0
 709 };
 710
 711 __attribute__ ((weak))
 712 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 713     0, 0, 0, 0, 0, 0, 0, 0,
 714     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 715     0, 0, 0, 0, 0, 0, 0, 0,
 716     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 717     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 718     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 719     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 720     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 721     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 722     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 723     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 724     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 725     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 726     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 727     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 728     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 729 };
 730
 731 void send_string(const char *str) {
 732   send_string_with_delay(str, 0);
 733 }
 734
 735 void send_string_P(const char *str) {
 736   send_string_with_delay_P(str, 0);
 737 }
 738
 739 void send_string_with_delay(const char *str, uint8_t interval) {
 740     while (1) {
 741         char ascii_code = *str;
 742         if (!ascii_code) break;
 743         if (ascii_code == 1) {
 744           // tap
 745           uint8_t keycode = *(++str);
 746           register_code(keycode);
 747           unregister_code(keycode);
 748         } else if (ascii_code == 2) {
 749           // down
 750           uint8_t keycode = *(++str);
 751           register_code(keycode);
 752         } else if (ascii_code == 3) {
 753           // up
 754           uint8_t keycode = *(++str);
 755           unregister_code(keycode);
 756         } else {
 757           send_char(ascii_code);
 758         }
 759         ++str;
 760         // interval
 761         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 762     }
 763 }
 764
 765 void send_string_with_delay_P(const char *str, uint8_t interval) {
 766     while (1) {
 767         char ascii_code = pgm_read_byte(str);
 768         if (!ascii_code) break;
 769         if (ascii_code == 1) {
 770           // tap
 771           uint8_t keycode = pgm_read_byte(++str);
 772           register_code(keycode);
 773           unregister_code(keycode);
 774         } else if (ascii_code == 2) {
 775           // down
 776           uint8_t keycode = pgm_read_byte(++str);
 777           register_code(keycode);
 778         } else if (ascii_code == 3) {
 779           // up
 780           uint8_t keycode = pgm_read_byte(++str);
 781           unregister_code(keycode);
 782         } else {
 783           send_char(ascii_code);
 784         }
 785         ++str;
 786         // interval
 787         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 788     }
 789 }
 790
 791 void send_char(char ascii_code) {
 792   uint8_t keycode;
 793   keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 794   if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
 795       register_code(KC_LSFT);
 796       register_code(keycode);
 797       unregister_code(keycode);
 798       unregister_code(KC_LSFT);
 799   } else {
 800       register_code(keycode);
 801       unregister_code(keycode);
 802   }
 803 }
 804
 805 void set_single_persistent_default_layer(uint8_t default_layer) {
 806   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 807     PLAY_SONG(default_layer_songs[default_layer]);
 808   #endif
 809   eeconfig_update_default_layer(1U<<default_layer);
 810   default_layer_set(1U<<default_layer);
 811 }
 812
 813 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 814   uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
 815   uint32_t mask3 = 1UL << layer3;
 816   return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
 817 }
 818
 819 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 820   layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
 821 }
 822
 823 void tap_random_base64(void) {
 824   #if defined(__AVR_ATmega32U4__)
 825     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 826   #else
 827     uint8_t key = rand() % 64;
 828   #endif
 829   switch (key) {
 830     case 0 ... 25:
 831       register_code(KC_LSFT);
 832       register_code(key + KC_A);
 833       unregister_code(key + KC_A);
 834       unregister_code(KC_LSFT);
 835       break;
 836     case 26 ... 51:
 837       register_code(key - 26 + KC_A);
 838       unregister_code(key - 26 + KC_A);
 839       break;
 840     case 52:
 841       register_code(KC_0);
 842       unregister_code(KC_0);
 843       break;
 844     case 53 ... 61:
 845       register_code(key - 53 + KC_1);
 846       unregister_code(key - 53 + KC_1);
 847       break;
 848     case 62:
 849       register_code(KC_LSFT);
 850       register_code(KC_EQL);
 851       unregister_code(KC_EQL);
 852       unregister_code(KC_LSFT);
 853       break;
 854     case 63:
 855       register_code(KC_SLSH);
 856       unregister_code(KC_SLSH);
 857       break;
 858   }
 859 }
 860
 861 void matrix_init_quantum() {
 862   #ifdef BACKLIGHT_ENABLE
 863     backlight_init_ports();
 864   #endif
 865   #ifdef AUDIO_ENABLE
 866     audio_init();
 867   #endif
 868   #ifdef RGB_MATRIX_ENABLE
 869     rgb_matrix_init();
 870   #endif
 871   matrix_init_kb();
 872 }
 873
 874 uint8_t rgb_matrix_task_counter = 0;
 875
 876 #ifndef RGB_MATRIX_SKIP_FRAMES
 877   #define RGB_MATRIX_SKIP_FRAMES 1
 878 #endif
 879
 880 void matrix_scan_quantum() {
 881   #if defined(AUDIO_ENABLE)
 882     matrix_scan_music();
 883   #endif
 884
 885   #ifdef TAP_DANCE_ENABLE
 886     matrix_scan_tap_dance();
 887   #endif
 888
 889   #ifdef COMBO_ENABLE
 890     matrix_scan_combo();
 891   #endif
 892
 893   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 894     backlight_task();
 895   #endif
 896
 897   #ifdef RGB_MATRIX_ENABLE
 898     rgb_matrix_task();
 899     if (rgb_matrix_task_counter == 0) {
 900       rgb_matrix_update_pwm_buffers();
 901     }
 902     rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
 903   #endif
 904
 905   matrix_scan_kb();
 906 }
 907 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 908
 909 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 910
 911 // depending on the pin, we use a different output compare unit
 912 #if BACKLIGHT_PIN == B7
 913 #  define COM1x1 COM1C1
 914 #  define OCR1x  OCR1C
 915 #elif BACKLIGHT_PIN == B6
 916 #  define COM1x1 COM1B1
 917 #  define OCR1x  OCR1B
 918 #elif BACKLIGHT_PIN == B5
 919 #  define COM1x1 COM1A1
 920 #  define OCR1x  OCR1A
 921 #else
 922 #  define NO_HARDWARE_PWM
 923 #endif
 924
 925 #ifndef BACKLIGHT_ON_STATE
 926 #define BACKLIGHT_ON_STATE 0
 927 #endif
 928
 929 #ifdef NO_HARDWARE_PWM // pwm through software
 930
 931 __attribute__ ((weak))
 932 void backlight_init_ports(void)
 933 {
 934   // Setup backlight pin as output and output to on state.
 935   // DDRx |= n
 936   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 937   #if BACKLIGHT_ON_STATE == 0
 938     // PORTx &= ~n
 939     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 940   #else
 941     // PORTx |= n
 942     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 943   #endif
 944 }
 945
 946 __attribute__ ((weak))
 947 void backlight_set(uint8_t level) {}
 948
 949 uint8_t backlight_tick = 0;
 950
 951 #ifndef BACKLIGHT_CUSTOM_DRIVER
 952 void backlight_task(void) {
 953   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 954     #if BACKLIGHT_ON_STATE == 0
 955       // PORTx &= ~n
 956       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 957     #else
 958       // PORTx |= n
 959       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 960     #endif
 961   } else {
 962     #if BACKLIGHT_ON_STATE == 0
 963       // PORTx |= n
 964       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 965     #else
 966       // PORTx &= ~n
 967       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 968     #endif
 969   }
 970   backlight_tick = (backlight_tick + 1) % 16;
 971 }
 972 #endif
 973
 974 #ifdef BACKLIGHT_BREATHING
 975   #ifndef BACKLIGHT_CUSTOM_DRIVER
 976   #error "Backlight breathing only available with hardware PWM. Please disable."
 977   #endif
 978 #endif
 979
 980 #else // pwm through timer
 981
 982 #define TIMER_TOP 0xFFFFU
 983
 984 // See http://jared.geek.nz/2013/feb/linear-led-pwm
 985 static uint16_t cie_lightness(uint16_t v) {
 986   if (v <= 5243) // if below 8% of max
 987     return v / 9; // same as dividing by 900%
 988   else {
 989     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
 990     // to get a useful result with integer division, we shift left in the expression above
 991     // and revert what we've done again after squaring.
 992     y = y * y * y >> 8;
 993     if (y > 0xFFFFUL) // prevent overflow
 994       return 0xFFFFU;
 995     else
 996       return (uint16_t) y;
 997   }
 998 }
 999
1000 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1001 static inline void set_pwm(uint16_t val) {
1002   OCR1x = val;
1003 }
1004
1005 #ifndef BACKLIGHT_CUSTOM_DRIVER
1006 __attribute__ ((weak))
1007 void backlight_set(uint8_t level) {
1008   if (level > BACKLIGHT_LEVELS)
1009     level = BACKLIGHT_LEVELS;
1010
1011   if (level == 0) {
1012     // Turn off PWM control on backlight pin
1013     TCCR1A &= ~(_BV(COM1x1));
1014   } else {
1015     // Turn on PWM control of backlight pin
1016     TCCR1A |= _BV(COM1x1);
1017   }
1018   // Set the brightness
1019   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1020 }
1021
1022 void backlight_task(void) {}
1023 #endif  // BACKLIGHT_CUSTOM_DRIVER
1024
1025 #ifdef BACKLIGHT_BREATHING
1026
1027 #define BREATHING_NO_HALT  0
1028 #define BREATHING_HALT_OFF 1
1029 #define BREATHING_HALT_ON  2
1030 #define BREATHING_STEPS 128
1031
1032 static uint8_t breathing_period = BREATHING_PERIOD;
1033 static uint8_t breathing_halt = BREATHING_NO_HALT;
1034 static uint16_t breathing_counter = 0;
1035
1036 bool is_breathing(void) {
1037     return !!(TIMSK1 & _BV(TOIE1));
1038 }
1039
1040 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1041 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1042 #define breathing_min() do {breathing_counter = 0;} while (0)
1043 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1044
1045 void breathing_enable(void)
1046 {
1047   breathing_counter = 0;
1048   breathing_halt = BREATHING_NO_HALT;
1049   breathing_interrupt_enable();
1050 }
1051
1052 void breathing_pulse(void)
1053 {
1054     if (get_backlight_level() == 0)
1055       breathing_min();
1056     else
1057       breathing_max();
1058     breathing_halt = BREATHING_HALT_ON;
1059     breathing_interrupt_enable();
1060 }
1061
1062 void breathing_disable(void)
1063 {
1064     breathing_interrupt_disable();
1065     // Restore backlight level
1066     backlight_set(get_backlight_level());
1067 }
1068
1069 void breathing_self_disable(void)
1070 {
1071   if (get_backlight_level() == 0)
1072     breathing_halt = BREATHING_HALT_OFF;
1073   else
1074     breathing_halt = BREATHING_HALT_ON;
1075 }
1076
1077 void breathing_toggle(void) {
1078   if (is_breathing())
1079     breathing_disable();
1080   else
1081     breathing_enable();
1082 }
1083
1084 void breathing_period_set(uint8_t value)
1085 {
1086   if (!value)
1087     value = 1;
1088   breathing_period = value;
1089 }
1090
1091 void breathing_period_default(void) {
1092   breathing_period_set(BREATHING_PERIOD);
1093 }
1094
1095 void breathing_period_inc(void)
1096 {
1097   breathing_period_set(breathing_period+1);
1098 }
1099
1100 void breathing_period_dec(void)
1101 {
1102   breathing_period_set(breathing_period-1);
1103 }
1104
1105 /* To generate breathing curve in python:
1106  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1107  */
1108 static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1109
1110 // Use this before the cie_lightness function.
1111 static inline uint16_t scale_backlight(uint16_t v) {
1112   return v / BACKLIGHT_LEVELS * get_backlight_level();
1113 }
1114
1115 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1116  * about 244 times per second.
1117  */
1118 ISR(TIMER1_OVF_vect)
1119 {
1120   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1121   // resetting after one period to prevent ugly reset at overflow.
1122   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1123   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1124
1125   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1126       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1127   {
1128       breathing_interrupt_disable();
1129   }
1130
1131   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1132 }
1133
1134 #endif // BACKLIGHT_BREATHING
1135
1136 __attribute__ ((weak))
1137 void backlight_init_ports(void)
1138 {
1139   // Setup backlight pin as output and output to on state.
1140   // DDRx |= n
1141   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1142   #if BACKLIGHT_ON_STATE == 0
1143     // PORTx &= ~n
1144     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1145   #else
1146     // PORTx |= n
1147     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1148   #endif
1149   // I could write a wall of text here to explain... but TL;DW
1150   // Go read the ATmega32u4 datasheet.
1151   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1152
1153   // Pin PB7 = OCR1C (Timer 1, Channel C)
1154   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1155   // (i.e. start high, go low when counter matches.)
1156   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1157   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1158
1159   /*
1160   14.8.3:
1161   "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]."
1162   "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)."
1163   */
1164
1165   TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
1166   TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1167   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1168   ICR1 = TIMER_TOP;
1169
1170   backlight_init();
1171   #ifdef BACKLIGHT_BREATHING
1172     breathing_enable();
1173   #endif
1174 }
1175
1176 #endif // NO_HARDWARE_PWM
1177
1178 #else // backlight
1179
1180 __attribute__ ((weak))
1181 void backlight_init_ports(void) {}
1182
1183 __attribute__ ((weak))
1184 void backlight_set(uint8_t level) {}
1185
1186 #endif // backlight
1187
1188
1189 // Functions for spitting out values
1190 //
1191
1192 void send_dword(uint32_t number) { // this might not actually work
1193     uint16_t word = (number >> 16);
1194     send_word(word);
1195     send_word(number & 0xFFFFUL);
1196 }
1197
1198 void send_word(uint16_t number) {
1199     uint8_t byte = number >> 8;
1200     send_byte(byte);
1201     send_byte(number & 0xFF);
1202 }
1203
1204 void send_byte(uint8_t number) {
1205     uint8_t nibble = number >> 4;
1206     send_nibble(nibble);
1207     send_nibble(number & 0xF);
1208 }
1209
1210 void send_nibble(uint8_t number) {
1211     switch (number) {
1212         case 0:
1213             register_code(KC_0);
1214             unregister_code(KC_0);
1215             break;
1216         case 1 ... 9:
1217             register_code(KC_1 + (number - 1));
1218             unregister_code(KC_1 + (number - 1));
1219             break;
1220         case 0xA ... 0xF:
1221             register_code(KC_A + (number - 0xA));
1222             unregister_code(KC_A + (number - 0xA));
1223             break;
1224     }
1225 }
1226
1227
1228 __attribute__((weak))
1229 uint16_t hex_to_keycode(uint8_t hex)
1230 {
1231   hex = hex & 0xF;
1232   if (hex == 0x0) {
1233     return KC_0;
1234   } else if (hex < 0xA) {
1235     return KC_1 + (hex - 0x1);
1236   } else {
1237     return KC_A + (hex - 0xA);
1238   }
1239 }
1240
1241 void api_send_unicode(uint32_t unicode) {
1242 #ifdef API_ENABLE
1243     uint8_t chunk[4];
1244     dword_to_bytes(unicode, chunk);
1245     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1246 #endif
1247 }
1248
1249 __attribute__ ((weak))
1250 void led_set_user(uint8_t usb_led) {
1251
1252 }
1253
1254 __attribute__ ((weak))
1255 void led_set_kb(uint8_t usb_led) {
1256     led_set_user(usb_led);
1257 }
1258
1259 __attribute__ ((weak))
1260 void led_init_ports(void)
1261 {
1262
1263 }
1264
1265 __attribute__ ((weak))
1266 void led_set(uint8_t usb_led)
1267 {
1268
1269   // Example LED Code
1270   //
1271     // // Using PE6 Caps Lock LED
1272     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1273     // {
1274     //     // Output high.
1275     //     DDRE |= (1<<6);
1276     //     PORTE |= (1<<6);
1277     // }
1278     // else
1279     // {
1280     //     // Output low.
1281     //     DDRE &= ~(1<<6);
1282     //     PORTE &= ~(1<<6);
1283     // }
1284
1285   led_set_kb(usb_led);
1286 }
1287
1288
1289 //------------------------------------------------------------------------------
1290 // Override these functions in your keymap file to play different tunes on
1291 // different events such as startup and bootloader jump
1292
1293 __attribute__ ((weak))
1294 void startup_user() {}
1295
1296 __attribute__ ((weak))
1297 void shutdown_user() {}
1298
1299 //------------------------------------------------------------------------------