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