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