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_HUI:
 342     if (record->event.pressed) {
 343       rgblight_increase_hue();
 344     }
 345     return false;
 346   case RGB_HUD:
 347     if (record->event.pressed) {
 348       rgblight_decrease_hue();
 349     }
 350     return false;
 351   case RGB_SAI:
 352     if (record->event.pressed) {
 353       rgblight_increase_sat();
 354     }
 355     return false;
 356   case RGB_SAD:
 357     if (record->event.pressed) {
 358       rgblight_decrease_sat();
 359     }
 360     return false;
 361   case RGB_VAI:
 362     if (record->event.pressed) {
 363       rgblight_increase_val();
 364     }
 365     return false;
 366   case RGB_VAD:
 367     if (record->event.pressed) {
 368       rgblight_decrease_val();
 369     }
 370     return false;
 371   case RGB_SPI:
 372     if (record->event.pressed) {
 373       rgblight_increase_speed();
 374     }
 375     return false;
 376   case RGB_SPD:
 377     if (record->event.pressed) {
 378       rgblight_decrease_speed();
 379     }
 380     return false;
 381   case RGB_MODE_PLAIN:
 382     if (record->event.pressed) {
 383       rgblight_mode(1);
 384     }
 385     return false;
 386   case RGB_MODE_BREATHE:
 387     if (record->event.pressed) {
 388       if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
 389         rgblight_step();
 390       } else {
 391         rgblight_mode(2);
 392       }
 393     }
 394     return false;
 395   case RGB_MODE_RAINBOW:
 396     if (record->event.pressed) {
 397       if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
 398         rgblight_step();
 399       } else {
 400         rgblight_mode(6);
 401       }
 402     }
 403     return false;
 404   case RGB_MODE_SWIRL:
 405     if (record->event.pressed) {
 406       if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
 407         rgblight_step();
 408       } else {
 409         rgblight_mode(9);
 410       }
 411     }
 412     return false;
 413   case RGB_MODE_SNAKE:
 414     if (record->event.pressed) {
 415       if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
 416         rgblight_step();
 417       } else {
 418         rgblight_mode(15);
 419       }
 420     }
 421     return false;
 422   case RGB_MODE_KNIGHT:
 423     if (record->event.pressed) {
 424       if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
 425         rgblight_step();
 426       } else {
 427         rgblight_mode(21);
 428       }
 429     }
 430     return false;
 431   case RGB_MODE_XMAS:
 432     if (record->event.pressed) {
 433       rgblight_mode(24);
 434     }
 435     return false;
 436   case RGB_MODE_GRADIENT:
 437     if (record->event.pressed) {
 438       if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
 439         rgblight_step();
 440       } else {
 441         rgblight_mode(25);
 442       }
 443     }
 444     return false;
 445   case RGB_MODE_RGBTEST:
 446     if (record->event.pressed) {
 447       rgblight_mode(35);
 448     }
 449     return false;
 450   #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 451     #ifdef PROTOCOL_LUFA
 452     case OUT_AUTO:
 453       if (record->event.pressed) {
 454         set_output(OUTPUT_AUTO);
 455       }
 456       return false;
 457     case OUT_USB:
 458       if (record->event.pressed) {
 459         set_output(OUTPUT_USB);
 460       }
 461       return false;
 462     #ifdef BLUETOOTH_ENABLE
 463     case OUT_BT:
 464       if (record->event.pressed) {
 465         set_output(OUTPUT_BLUETOOTH);
 466       }
 467       return false;
 468     #endif
 469     #endif
 470     case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
 471       if (record->event.pressed) {
 472         // MAGIC actions (BOOTMAGIC without the boot)
 473         if (!eeconfig_is_enabled()) {
 474             eeconfig_init();
 475         }
 476         /* keymap config */
 477         keymap_config.raw = eeconfig_read_keymap();
 478         switch (keycode)
 479         {
 480           case MAGIC_SWAP_CONTROL_CAPSLOCK:
 481             keymap_config.swap_control_capslock = true;
 482             break;
 483           case MAGIC_CAPSLOCK_TO_CONTROL:
 484             keymap_config.capslock_to_control = true;
 485             break;
 486           case MAGIC_SWAP_LALT_LGUI:
 487             keymap_config.swap_lalt_lgui = true;
 488             break;
 489           case MAGIC_SWAP_RALT_RGUI:
 490             keymap_config.swap_ralt_rgui = true;
 491             break;
 492           case MAGIC_NO_GUI:
 493             keymap_config.no_gui = true;
 494             break;
 495           case MAGIC_SWAP_GRAVE_ESC:
 496             keymap_config.swap_grave_esc = true;
 497             break;
 498           case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 499             keymap_config.swap_backslash_backspace = true;
 500             break;
 501           case MAGIC_HOST_NKRO:
 502             keymap_config.nkro = true;
 503             break;
 504           case MAGIC_SWAP_ALT_GUI:
 505             keymap_config.swap_lalt_lgui = true;
 506             keymap_config.swap_ralt_rgui = true;
 507             #ifdef AUDIO_ENABLE
 508               PLAY_SONG(ag_swap_song);
 509             #endif
 510             break;
 511           case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 512             keymap_config.swap_control_capslock = false;
 513             break;
 514           case MAGIC_UNCAPSLOCK_TO_CONTROL:
 515             keymap_config.capslock_to_control = false;
 516             break;
 517           case MAGIC_UNSWAP_LALT_LGUI:
 518             keymap_config.swap_lalt_lgui = false;
 519             break;
 520           case MAGIC_UNSWAP_RALT_RGUI:
 521             keymap_config.swap_ralt_rgui = false;
 522             break;
 523           case MAGIC_UNNO_GUI:
 524             keymap_config.no_gui = false;
 525             break;
 526           case MAGIC_UNSWAP_GRAVE_ESC:
 527             keymap_config.swap_grave_esc = false;
 528             break;
 529           case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 530             keymap_config.swap_backslash_backspace = false;
 531             break;
 532           case MAGIC_UNHOST_NKRO:
 533             keymap_config.nkro = false;
 534             break;
 535           case MAGIC_UNSWAP_ALT_GUI:
 536             keymap_config.swap_lalt_lgui = false;
 537             keymap_config.swap_ralt_rgui = false;
 538             #ifdef AUDIO_ENABLE
 539               PLAY_SONG(ag_norm_song);
 540             #endif
 541             break;
 542           case MAGIC_TOGGLE_NKRO:
 543             keymap_config.nkro = !keymap_config.nkro;
 544             break;
 545           default:
 546             break;
 547         }
 548         eeconfig_update_keymap(keymap_config.raw);
 549         clear_keyboard(); // clear to prevent stuck keys
 550
 551         return false;
 552       }
 553       break;
 554     case KC_LSPO: {
 555       if (record->event.pressed) {
 556         shift_interrupted[0] = false;
 557         scs_timer[0] = timer_read ();
 558         register_mods(MOD_BIT(KC_LSFT));
 559       }
 560       else {
 561         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 562           if (get_mods() & MOD_BIT(KC_RSFT)) {
 563             shift_interrupted[0] = true;
 564             shift_interrupted[1] = true;
 565           }
 566         #endif
 567         if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
 568           register_code(LSPO_KEY);
 569           unregister_code(LSPO_KEY);
 570         }
 571         unregister_mods(MOD_BIT(KC_LSFT));
 572       }
 573       return false;
 574     }
 575
 576     case KC_RSPC: {
 577       if (record->event.pressed) {
 578         shift_interrupted[1] = false;
 579         scs_timer[1] = timer_read ();
 580         register_mods(MOD_BIT(KC_RSFT));
 581       }
 582       else {
 583         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 584           if (get_mods() & MOD_BIT(KC_LSFT)) {
 585             shift_interrupted[0] = true;
 586             shift_interrupted[1] = true;
 587           }
 588         #endif
 589         if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 590           register_code(RSPC_KEY);
 591           unregister_code(RSPC_KEY);
 592         }
 593         unregister_mods(MOD_BIT(KC_RSFT));
 594       }
 595       return false;
 596     }
 597
 598     case KC_SFTENT: {
 599       if (record->event.pressed) {
 600         shift_interrupted[1] = false;
 601         scs_timer[1] = timer_read ();
 602         register_mods(MOD_BIT(KC_RSFT));
 603       }
 604       else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 605         unregister_mods(MOD_BIT(KC_RSFT));
 606         register_code(SFTENT_KEY);
 607         unregister_code(SFTENT_KEY);
 608       }
 609       else {
 610         unregister_mods(MOD_BIT(KC_RSFT));
 611       }
 612       return false;
 613     }
 614
 615     case GRAVE_ESC: {
 616       uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
 617                                       |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
 618
 619 #ifdef GRAVE_ESC_ALT_OVERRIDE
 620       // if ALT is pressed, ESC is always sent
 621       // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 622       if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 623         shifted = 0;
 624       }
 625 #endif
 626
 627 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 628       // if CTRL is pressed, ESC is always sent
 629       // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 630       if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 631         shifted = 0;
 632       }
 633 #endif
 634
 635 #ifdef GRAVE_ESC_GUI_OVERRIDE
 636       // if GUI is pressed, ESC is always sent
 637       if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 638         shifted = 0;
 639       }
 640 #endif
 641
 642 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 643       // if SHIFT is pressed, ESC is always sent
 644       if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 645         shifted = 0;
 646       }
 647 #endif
 648
 649       if (record->event.pressed) {
 650         grave_esc_was_shifted = shifted;
 651         add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 652       }
 653       else {
 654         del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 655       }
 656
 657       send_keyboard_report();
 658       return false;
 659     }
 660
 661 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
 662     case BL_BRTG: {
 663       if (record->event.pressed)
 664         breathing_toggle();
 665       return false;
 666     }
 667 #endif
 668
 669     default: {
 670       shift_interrupted[0] = true;
 671       shift_interrupted[1] = true;
 672       break;
 673     }
 674   }
 675
 676   return process_action_kb(record);
 677 }
 678
 679 __attribute__ ((weak))
 680 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 681     0, 0, 0, 0, 0, 0, 0, 0,
 682     0, 0, 0, 0, 0, 0, 0, 0,
 683     0, 0, 0, 0, 0, 0, 0, 0,
 684     0, 0, 0, 0, 0, 0, 0, 0,
 685     0, 1, 1, 1, 1, 1, 1, 0,
 686     1, 1, 1, 1, 0, 0, 0, 0,
 687     0, 0, 0, 0, 0, 0, 0, 0,
 688     0, 0, 1, 0, 1, 0, 1, 1,
 689     1, 1, 1, 1, 1, 1, 1, 1,
 690     1, 1, 1, 1, 1, 1, 1, 1,
 691     1, 1, 1, 1, 1, 1, 1, 1,
 692     1, 1, 1, 0, 0, 0, 1, 1,
 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, 1, 1, 1, 1, 0
 697 };
 698
 699 __attribute__ ((weak))
 700 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 701     0, 0, 0, 0, 0, 0, 0, 0,
 702     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 703     0, 0, 0, 0, 0, 0, 0, 0,
 704     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 705     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 706     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 707     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 708     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 709     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 710     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 711     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 712     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 713     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 714     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 715     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 716     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 717 };
 718
 719 void send_string(const char *str) {
 720   send_string_with_delay(str, 0);
 721 }
 722
 723 void send_string_P(const char *str) {
 724   send_string_with_delay_P(str, 0);
 725 }
 726
 727 void send_string_with_delay(const char *str, uint8_t interval) {
 728     while (1) {
 729         char ascii_code = *str;
 730         if (!ascii_code) break;
 731         if (ascii_code == 1) {
 732           // tap
 733           uint8_t keycode = *(++str);
 734           register_code(keycode);
 735           unregister_code(keycode);
 736         } else if (ascii_code == 2) {
 737           // down
 738           uint8_t keycode = *(++str);
 739           register_code(keycode);
 740         } else if (ascii_code == 3) {
 741           // up
 742           uint8_t keycode = *(++str);
 743           unregister_code(keycode);
 744         } else {
 745           send_char(ascii_code);
 746         }
 747         ++str;
 748         // interval
 749         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 750     }
 751 }
 752
 753 void send_string_with_delay_P(const char *str, uint8_t interval) {
 754     while (1) {
 755         char ascii_code = pgm_read_byte(str);
 756         if (!ascii_code) break;
 757         if (ascii_code == 1) {
 758           // tap
 759           uint8_t keycode = pgm_read_byte(++str);
 760           register_code(keycode);
 761           unregister_code(keycode);
 762         } else if (ascii_code == 2) {
 763           // down
 764           uint8_t keycode = pgm_read_byte(++str);
 765           register_code(keycode);
 766         } else if (ascii_code == 3) {
 767           // up
 768           uint8_t keycode = pgm_read_byte(++str);
 769           unregister_code(keycode);
 770         } else {
 771           send_char(ascii_code);
 772         }
 773         ++str;
 774         // interval
 775         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 776     }
 777 }
 778
 779 void send_char(char ascii_code) {
 780   uint8_t keycode;
 781   keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 782   if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
 783       register_code(KC_LSFT);
 784       register_code(keycode);
 785       unregister_code(keycode);
 786       unregister_code(KC_LSFT);
 787   } else {
 788       register_code(keycode);
 789       unregister_code(keycode);
 790   }
 791 }
 792
 793 void set_single_persistent_default_layer(uint8_t default_layer) {
 794   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 795     PLAY_SONG(default_layer_songs[default_layer]);
 796   #endif
 797   eeconfig_update_default_layer(1U<<default_layer);
 798   default_layer_set(1U<<default_layer);
 799 }
 800
 801 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 802   uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
 803   uint32_t mask3 = 1UL << layer3;
 804   return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
 805 }
 806
 807 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 808   layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
 809 }
 810
 811 void tap_random_base64(void) {
 812   #if defined(__AVR_ATmega32U4__)
 813     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 814   #else
 815     uint8_t key = rand() % 64;
 816   #endif
 817   switch (key) {
 818     case 0 ... 25:
 819       register_code(KC_LSFT);
 820       register_code(key + KC_A);
 821       unregister_code(key + KC_A);
 822       unregister_code(KC_LSFT);
 823       break;
 824     case 26 ... 51:
 825       register_code(key - 26 + KC_A);
 826       unregister_code(key - 26 + KC_A);
 827       break;
 828     case 52:
 829       register_code(KC_0);
 830       unregister_code(KC_0);
 831       break;
 832     case 53 ... 61:
 833       register_code(key - 53 + KC_1);
 834       unregister_code(key - 53 + KC_1);
 835       break;
 836     case 62:
 837       register_code(KC_LSFT);
 838       register_code(KC_EQL);
 839       unregister_code(KC_EQL);
 840       unregister_code(KC_LSFT);
 841       break;
 842     case 63:
 843       register_code(KC_SLSH);
 844       unregister_code(KC_SLSH);
 845       break;
 846   }
 847 }
 848
 849 void matrix_init_quantum() {
 850   #ifdef BACKLIGHT_ENABLE
 851     backlight_init_ports();
 852   #endif
 853   #ifdef AUDIO_ENABLE
 854     audio_init();
 855   #endif
 856   #ifdef RGB_MATRIX_ENABLE
 857     rgb_matrix_init();
 858   #endif
 859   matrix_init_kb();
 860 }
 861
 862 uint8_t rgb_matrix_task_counter = 0;
 863
 864 #ifndef RGB_MATRIX_SKIP_FRAMES
 865   #define RGB_MATRIX_SKIP_FRAMES 1
 866 #endif
 867
 868 void matrix_scan_quantum() {
 869   #if defined(AUDIO_ENABLE)
 870     matrix_scan_music();
 871   #endif
 872
 873   #ifdef TAP_DANCE_ENABLE
 874     matrix_scan_tap_dance();
 875   #endif
 876
 877   #ifdef COMBO_ENABLE
 878     matrix_scan_combo();
 879   #endif
 880
 881   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 882     backlight_task();
 883   #endif
 884
 885   #ifdef RGB_MATRIX_ENABLE
 886     rgb_matrix_task();
 887     if (rgb_matrix_task_counter == 0) {
 888       rgb_matrix_update_pwm_buffers();
 889     }
 890     rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
 891   #endif
 892
 893   matrix_scan_kb();
 894 }
 895 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 896
 897 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 898
 899 // depending on the pin, we use a different output compare unit
 900 #if BACKLIGHT_PIN == B7
 901 #  define TCCRxA TCCR1A
 902 #  define TCCRxB TCCR1B
 903 #  define COMxx1 COM1C1
 904 #  define OCRxx  OCR1C
 905 #  define ICRx   ICR1
 906 #elif BACKLIGHT_PIN == B6
 907 #  define TCCRxA TCCR1A
 908 #  define TCCRxB TCCR1B
 909 #  define COMxx1 COM1B1
 910 #  define OCRxx  OCR1B
 911 #  define ICRx   ICR1
 912 #elif BACKLIGHT_PIN == B5
 913 #  define TCCRxA TCCR1A
 914 #  define TCCRxB TCCR1B
 915 #  define COMxx1 COM1A1
 916 #  define OCRxx  OCR1A
 917 #  define ICRx   ICR1
 918 #elif BACKLIGHT_PIN == C6
 919 #  define TCCRxA TCCR3A
 920 #  define TCCRxB TCCR3B
 921 #  define COMxx1 COM1A1
 922 #  define OCRxx  OCR3A
 923 #  define ICRx   ICR3
 924 #else
 925 #  define NO_HARDWARE_PWM
 926 #endif
 927
 928 #ifndef BACKLIGHT_ON_STATE
 929 #define BACKLIGHT_ON_STATE 0
 930 #endif
 931
 932 #ifdef NO_HARDWARE_PWM // pwm through software
 933
 934 __attribute__ ((weak))
 935 void backlight_init_ports(void)
 936 {
 937   // Setup backlight pin as output and output to on state.
 938   // DDRx |= n
 939   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 940   #if BACKLIGHT_ON_STATE == 0
 941     // PORTx &= ~n
 942     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 943   #else
 944     // PORTx |= n
 945     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 946   #endif
 947 }
 948
 949 __attribute__ ((weak))
 950 void backlight_set(uint8_t level) {}
 951
 952 uint8_t backlight_tick = 0;
 953
 954 #ifndef BACKLIGHT_CUSTOM_DRIVER
 955 void backlight_task(void) {
 956   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 957     #if BACKLIGHT_ON_STATE == 0
 958       // PORTx &= ~n
 959       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 960     #else
 961       // PORTx |= n
 962       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 963     #endif
 964   } else {
 965     #if BACKLIGHT_ON_STATE == 0
 966       // PORTx |= n
 967       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 968     #else
 969       // PORTx &= ~n
 970       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 971     #endif
 972   }
 973   backlight_tick = (backlight_tick + 1) % 16;
 974 }
 975 #endif
 976
 977 #ifdef BACKLIGHT_BREATHING
 978   #ifndef BACKLIGHT_CUSTOM_DRIVER
 979   #error "Backlight breathing only available with hardware PWM. Please disable."
 980   #endif
 981 #endif
 982
 983 #else // pwm through timer
 984
 985 #define TIMER_TOP 0xFFFFU
 986
 987 // See http://jared.geek.nz/2013/feb/linear-led-pwm
 988 static uint16_t cie_lightness(uint16_t v) {
 989   if (v <= 5243) // if below 8% of max
 990     return v / 9; // same as dividing by 900%
 991   else {
 992     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
 993     // to get a useful result with integer division, we shift left in the expression above
 994     // and revert what we've done again after squaring.
 995     y = y * y * y >> 8;
 996     if (y > 0xFFFFUL) // prevent overflow
 997       return 0xFFFFU;
 998     else
 999       return (uint16_t) y;
1000   }
1001 }
1002
1003 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1004 static inline void set_pwm(uint16_t val) {
1005         OCRxx = val;
1006 }
1007
1008 #ifndef BACKLIGHT_CUSTOM_DRIVER
1009 __attribute__ ((weak))
1010 void backlight_set(uint8_t level) {
1011   if (level > BACKLIGHT_LEVELS)
1012     level = BACKLIGHT_LEVELS;
1013
1014   if (level == 0) {
1015     // Turn off PWM control on backlight pin
1016     TCCRxA &= ~(_BV(COMxx1));
1017   } else {
1018     // Turn on PWM control of backlight pin
1019     TCCRxA |= _BV(COMxx1);
1020   }
1021   // Set the brightness
1022   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1023 }
1024
1025 void backlight_task(void) {}
1026 #endif  // BACKLIGHT_CUSTOM_DRIVER
1027
1028 #ifdef BACKLIGHT_BREATHING
1029
1030 #define BREATHING_NO_HALT  0
1031 #define BREATHING_HALT_OFF 1
1032 #define BREATHING_HALT_ON  2
1033 #define BREATHING_STEPS 128
1034
1035 static uint8_t breathing_period = BREATHING_PERIOD;
1036 static uint8_t breathing_halt = BREATHING_NO_HALT;
1037 static uint16_t breathing_counter = 0;
1038
1039 bool is_breathing(void) {
1040     return !!(TIMSK1 & _BV(TOIE1));
1041 }
1042
1043 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1044 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1045 #define breathing_min() do {breathing_counter = 0;} while (0)
1046 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1047
1048 void breathing_enable(void)
1049 {
1050   breathing_counter = 0;
1051   breathing_halt = BREATHING_NO_HALT;
1052   breathing_interrupt_enable();
1053 }
1054
1055 void breathing_pulse(void)
1056 {
1057     if (get_backlight_level() == 0)
1058       breathing_min();
1059     else
1060       breathing_max();
1061     breathing_halt = BREATHING_HALT_ON;
1062     breathing_interrupt_enable();
1063 }
1064
1065 void breathing_disable(void)
1066 {
1067     breathing_interrupt_disable();
1068     // Restore backlight level
1069     backlight_set(get_backlight_level());
1070 }
1071
1072 void breathing_self_disable(void)
1073 {
1074   if (get_backlight_level() == 0)
1075     breathing_halt = BREATHING_HALT_OFF;
1076   else
1077     breathing_halt = BREATHING_HALT_ON;
1078 }
1079
1080 void breathing_toggle(void) {
1081   if (is_breathing())
1082     breathing_disable();
1083   else
1084     breathing_enable();
1085 }
1086
1087 void breathing_period_set(uint8_t value)
1088 {
1089   if (!value)
1090     value = 1;
1091   breathing_period = value;
1092 }
1093
1094 void breathing_period_default(void) {
1095   breathing_period_set(BREATHING_PERIOD);
1096 }
1097
1098 void breathing_period_inc(void)
1099 {
1100   breathing_period_set(breathing_period+1);
1101 }
1102
1103 void breathing_period_dec(void)
1104 {
1105   breathing_period_set(breathing_period-1);
1106 }
1107
1108 /* To generate breathing curve in python:
1109  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1110  */
1111 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};
1112
1113 // Use this before the cie_lightness function.
1114 static inline uint16_t scale_backlight(uint16_t v) {
1115   return v / BACKLIGHT_LEVELS * get_backlight_level();
1116 }
1117
1118 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1119  * about 244 times per second.
1120  */
1121 ISR(TIMER1_OVF_vect)
1122 {
1123   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1124   // resetting after one period to prevent ugly reset at overflow.
1125   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1126   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1127
1128   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1129       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1130   {
1131       breathing_interrupt_disable();
1132   }
1133
1134   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1135 }
1136
1137 #endif // BACKLIGHT_BREATHING
1138
1139 __attribute__ ((weak))
1140 void backlight_init_ports(void)
1141 {
1142   // Setup backlight pin as output and output to on state.
1143   // DDRx |= n
1144   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1145   #if BACKLIGHT_ON_STATE == 0
1146     // PORTx &= ~n
1147     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1148   #else
1149     // PORTx |= n
1150     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1151   #endif
1152   // I could write a wall of text here to explain... but TL;DW
1153   // Go read the ATmega32u4 datasheet.
1154   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1155
1156   // Pin PB7 = OCR1C (Timer 1, Channel C)
1157   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1158   // (i.e. start high, go low when counter matches.)
1159   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1160   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1161
1162   /*
1163   14.8.3:
1164   "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 [..]."
1165   "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)."
1166   */
1167   TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1168   TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1169   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1170   ICRx = TIMER_TOP;
1171
1172   backlight_init();
1173   #ifdef BACKLIGHT_BREATHING
1174     breathing_enable();
1175   #endif
1176 }
1177
1178 #endif // NO_HARDWARE_PWM
1179
1180 #else // backlight
1181
1182 __attribute__ ((weak))
1183 void backlight_init_ports(void) {}
1184
1185 __attribute__ ((weak))
1186 void backlight_set(uint8_t level) {}
1187
1188 #endif // backlight
1189
1190 #ifdef HD44780_ENABLED
1191 #include "hd44780.h"
1192 #endif
1193
1194
1195 // Functions for spitting out values
1196 //
1197
1198 void send_dword(uint32_t number) { // this might not actually work
1199     uint16_t word = (number >> 16);
1200     send_word(word);
1201     send_word(number & 0xFFFFUL);
1202 }
1203
1204 void send_word(uint16_t number) {
1205     uint8_t byte = number >> 8;
1206     send_byte(byte);
1207     send_byte(number & 0xFF);
1208 }
1209
1210 void send_byte(uint8_t number) {
1211     uint8_t nibble = number >> 4;
1212     send_nibble(nibble);
1213     send_nibble(number & 0xF);
1214 }
1215
1216 void send_nibble(uint8_t number) {
1217     switch (number) {
1218         case 0:
1219             register_code(KC_0);
1220             unregister_code(KC_0);
1221             break;
1222         case 1 ... 9:
1223             register_code(KC_1 + (number - 1));
1224             unregister_code(KC_1 + (number - 1));
1225             break;
1226         case 0xA ... 0xF:
1227             register_code(KC_A + (number - 0xA));
1228             unregister_code(KC_A + (number - 0xA));
1229             break;
1230     }
1231 }
1232
1233
1234 __attribute__((weak))
1235 uint16_t hex_to_keycode(uint8_t hex)
1236 {
1237   hex = hex & 0xF;
1238   if (hex == 0x0) {
1239     return KC_0;
1240   } else if (hex < 0xA) {
1241     return KC_1 + (hex - 0x1);
1242   } else {
1243     return KC_A + (hex - 0xA);
1244   }
1245 }
1246
1247 void api_send_unicode(uint32_t unicode) {
1248 #ifdef API_ENABLE
1249     uint8_t chunk[4];
1250     dword_to_bytes(unicode, chunk);
1251     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1252 #endif
1253 }
1254
1255 __attribute__ ((weak))
1256 void led_set_user(uint8_t usb_led) {
1257
1258 }
1259
1260 __attribute__ ((weak))
1261 void led_set_kb(uint8_t usb_led) {
1262     led_set_user(usb_led);
1263 }
1264
1265 __attribute__ ((weak))
1266 void led_init_ports(void)
1267 {
1268
1269 }
1270
1271 __attribute__ ((weak))
1272 void led_set(uint8_t usb_led)
1273 {
1274
1275   // Example LED Code
1276   //
1277     // // Using PE6 Caps Lock LED
1278     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1279     // {
1280     //     // Output high.
1281     //     DDRE |= (1<<6);
1282     //     PORTE |= (1<<6);
1283     // }
1284     // else
1285     // {
1286     //     // Output low.
1287     //     DDRE &= ~(1<<6);
1288     //     PORTE &= ~(1<<6);
1289     // }
1290
1291   led_set_kb(usb_led);
1292 }
1293
1294
1295 //------------------------------------------------------------------------------
1296 // Override these functions in your keymap file to play different tunes on
1297 // different events such as startup and bootloader jump
1298
1299 __attribute__ ((weak))
1300 void startup_user() {}
1301
1302 __attribute__ ((weak))
1303 void shutdown_user() {}
1304
1305 //------------------------------------------------------------------------------