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