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