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 __attribute__((weak))
 953 void bootmagic_lite(void) {
 954   // The lite version of TMK's bootmagic based on Wilba.
 955   // 100% less potential for accidentally making the
 956   // keyboard do stupid things.
 957
 958   // We need multiple scans because debouncing can't be turned off.
 959   matrix_scan();
 960   #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
 961     wait_ms(DEBOUNCING_DELAY * 2);
 962   #elif defined(DEBOUNCE) && DEBOUNCE > 0
 963     wait_ms(DEBOUNCE * 2);
 964   #else
 965     wait_ms(30);
 966   #endif
 967   matrix_scan();
 968
 969   // If the Esc and space bar are held down on power up,
 970   // reset the EEPROM valid state and jump to bootloader.
 971   // Assumes Esc is at [0,0].
 972   // This isn't very generalized, but we need something that doesn't
 973   // rely on user's keymaps in firmware or EEPROM.
 974   if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
 975     eeconfig_disable();
 976     // Jump to bootloader.
 977     bootloader_jump();
 978   }
 979 }
 980
 981 void matrix_init_quantum() {
 982   #ifdef BOOTMAGIC_LITE
 983     bootmagic_lite();
 984   #endif
 985   if (!eeconfig_is_enabled()) {
 986     eeconfig_init();
 987   }
 988   #ifdef BACKLIGHT_ENABLE
 989     backlight_init_ports();
 990   #endif
 991   #ifdef AUDIO_ENABLE
 992     audio_init();
 993   #endif
 994   #ifdef RGB_MATRIX_ENABLE
 995     rgb_matrix_init();
 996   #endif
 997   #ifdef ENCODER_ENABLE
 998     encoder_init();
 999   #endif
1000   matrix_init_kb();
1001 }
1002
1003 uint8_t rgb_matrix_task_counter = 0;
1004
1005 #ifndef RGB_MATRIX_SKIP_FRAMES
1006   #define RGB_MATRIX_SKIP_FRAMES 1
1007 #endif
1008
1009 void matrix_scan_quantum() {
1010   #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1011     matrix_scan_music();
1012   #endif
1013
1014   #ifdef TAP_DANCE_ENABLE
1015     matrix_scan_tap_dance();
1016   #endif
1017
1018   #ifdef COMBO_ENABLE
1019     matrix_scan_combo();
1020   #endif
1021
1022   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1023     backlight_task();
1024   #endif
1025
1026   #ifdef RGB_MATRIX_ENABLE
1027     rgb_matrix_task();
1028     if (rgb_matrix_task_counter == 0) {
1029       rgb_matrix_update_pwm_buffers();
1030     }
1031     rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1032   #endif
1033
1034   #ifdef ENCODER_ENABLE
1035     encoder_read();
1036   #endif
1037
1038   matrix_scan_kb();
1039 }
1040 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1041
1042 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1043
1044 // depending on the pin, we use a different output compare unit
1045 #if BACKLIGHT_PIN == B7
1046 #  define TCCRxA TCCR1A
1047 #  define TCCRxB TCCR1B
1048 #  define COMxx1 COM1C1
1049 #  define OCRxx  OCR1C
1050 #  define ICRx   ICR1
1051 #elif BACKLIGHT_PIN == B6
1052 #  define TCCRxA TCCR1A
1053 #  define TCCRxB TCCR1B
1054 #  define COMxx1 COM1B1
1055 #  define OCRxx  OCR1B
1056 #  define ICRx   ICR1
1057 #elif BACKLIGHT_PIN == B5
1058 #  define TCCRxA TCCR1A
1059 #  define TCCRxB TCCR1B
1060 #  define COMxx1 COM1A1
1061 #  define OCRxx  OCR1A
1062 #  define ICRx   ICR1
1063 #elif BACKLIGHT_PIN == C6
1064 #  define TCCRxA TCCR3A
1065 #  define TCCRxB TCCR3B
1066 #  define COMxx1 COM1A1
1067 #  define OCRxx  OCR3A
1068 #  define ICRx   ICR3
1069 #else
1070 #  define NO_HARDWARE_PWM
1071 #endif
1072
1073 #ifndef BACKLIGHT_ON_STATE
1074 #define BACKLIGHT_ON_STATE 0
1075 #endif
1076
1077 #ifdef NO_HARDWARE_PWM // pwm through software
1078
1079 __attribute__ ((weak))
1080 void backlight_init_ports(void)
1081 {
1082   // Setup backlight pin as output and output to on state.
1083   // DDRx |= n
1084   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1085   #if BACKLIGHT_ON_STATE == 0
1086     // PORTx &= ~n
1087     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1088   #else
1089     // PORTx |= n
1090     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1091   #endif
1092 }
1093
1094 __attribute__ ((weak))
1095 void backlight_set(uint8_t level) {}
1096
1097 uint8_t backlight_tick = 0;
1098
1099 #ifndef BACKLIGHT_CUSTOM_DRIVER
1100 void backlight_task(void) {
1101   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1102     #if BACKLIGHT_ON_STATE == 0
1103       // PORTx &= ~n
1104       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1105     #else
1106       // PORTx |= n
1107       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1108     #endif
1109   } else {
1110     #if BACKLIGHT_ON_STATE == 0
1111       // PORTx |= n
1112       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1113     #else
1114       // PORTx &= ~n
1115       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1116     #endif
1117   }
1118   backlight_tick = (backlight_tick + 1) % 16;
1119 }
1120 #endif
1121
1122 #ifdef BACKLIGHT_BREATHING
1123   #ifndef BACKLIGHT_CUSTOM_DRIVER
1124   #error "Backlight breathing only available with hardware PWM. Please disable."
1125   #endif
1126 #endif
1127
1128 #else // pwm through timer
1129
1130 #define TIMER_TOP 0xFFFFU
1131
1132 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1133 static uint16_t cie_lightness(uint16_t v) {
1134   if (v <= 5243) // if below 8% of max
1135     return v / 9; // same as dividing by 900%
1136   else {
1137     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1138     // to get a useful result with integer division, we shift left in the expression above
1139     // and revert what we've done again after squaring.
1140     y = y * y * y >> 8;
1141     if (y > 0xFFFFUL) // prevent overflow
1142       return 0xFFFFU;
1143     else
1144       return (uint16_t) y;
1145   }
1146 }
1147
1148 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1149 static inline void set_pwm(uint16_t val) {
1150         OCRxx = val;
1151 }
1152
1153 #ifndef BACKLIGHT_CUSTOM_DRIVER
1154 __attribute__ ((weak))
1155 void backlight_set(uint8_t level) {
1156   if (level > BACKLIGHT_LEVELS)
1157     level = BACKLIGHT_LEVELS;
1158
1159   if (level == 0) {
1160     // Turn off PWM control on backlight pin
1161     TCCRxA &= ~(_BV(COMxx1));
1162   } else {
1163     // Turn on PWM control of backlight pin
1164     TCCRxA |= _BV(COMxx1);
1165   }
1166   // Set the brightness
1167   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1168 }
1169
1170 void backlight_task(void) {}
1171 #endif  // BACKLIGHT_CUSTOM_DRIVER
1172
1173 #ifdef BACKLIGHT_BREATHING
1174
1175 #define BREATHING_NO_HALT  0
1176 #define BREATHING_HALT_OFF 1
1177 #define BREATHING_HALT_ON  2
1178 #define BREATHING_STEPS 128
1179
1180 static uint8_t breathing_period = BREATHING_PERIOD;
1181 static uint8_t breathing_halt = BREATHING_NO_HALT;
1182 static uint16_t breathing_counter = 0;
1183
1184 bool is_breathing(void) {
1185     return !!(TIMSK1 & _BV(TOIE1));
1186 }
1187
1188 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1189 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1190 #define breathing_min() do {breathing_counter = 0;} while (0)
1191 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1192
1193 void breathing_enable(void)
1194 {
1195   breathing_counter = 0;
1196   breathing_halt = BREATHING_NO_HALT;
1197   breathing_interrupt_enable();
1198 }
1199
1200 void breathing_pulse(void)
1201 {
1202     if (get_backlight_level() == 0)
1203       breathing_min();
1204     else
1205       breathing_max();
1206     breathing_halt = BREATHING_HALT_ON;
1207     breathing_interrupt_enable();
1208 }
1209
1210 void breathing_disable(void)
1211 {
1212     breathing_interrupt_disable();
1213     // Restore backlight level
1214     backlight_set(get_backlight_level());
1215 }
1216
1217 void breathing_self_disable(void)
1218 {
1219   if (get_backlight_level() == 0)
1220     breathing_halt = BREATHING_HALT_OFF;
1221   else
1222     breathing_halt = BREATHING_HALT_ON;
1223 }
1224
1225 void breathing_toggle(void) {
1226   if (is_breathing())
1227     breathing_disable();
1228   else
1229     breathing_enable();
1230 }
1231
1232 void breathing_period_set(uint8_t value)
1233 {
1234   if (!value)
1235     value = 1;
1236   breathing_period = value;
1237 }
1238
1239 void breathing_period_default(void) {
1240   breathing_period_set(BREATHING_PERIOD);
1241 }
1242
1243 void breathing_period_inc(void)
1244 {
1245   breathing_period_set(breathing_period+1);
1246 }
1247
1248 void breathing_period_dec(void)
1249 {
1250   breathing_period_set(breathing_period-1);
1251 }
1252
1253 /* To generate breathing curve in python:
1254  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1255  */
1256 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};
1257
1258 // Use this before the cie_lightness function.
1259 static inline uint16_t scale_backlight(uint16_t v) {
1260   return v / BACKLIGHT_LEVELS * get_backlight_level();
1261 }
1262
1263 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1264  * about 244 times per second.
1265  */
1266 ISR(TIMER1_OVF_vect)
1267 {
1268   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1269   // resetting after one period to prevent ugly reset at overflow.
1270   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1271   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1272
1273   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1274       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1275   {
1276       breathing_interrupt_disable();
1277   }
1278
1279   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1280 }
1281
1282 #endif // BACKLIGHT_BREATHING
1283
1284 __attribute__ ((weak))
1285 void backlight_init_ports(void)
1286 {
1287   // Setup backlight pin as output and output to on state.
1288   // DDRx |= n
1289   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1290   #if BACKLIGHT_ON_STATE == 0
1291     // PORTx &= ~n
1292     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1293   #else
1294     // PORTx |= n
1295     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1296   #endif
1297   // I could write a wall of text here to explain... but TL;DW
1298   // Go read the ATmega32u4 datasheet.
1299   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1300
1301   // Pin PB7 = OCR1C (Timer 1, Channel C)
1302   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1303   // (i.e. start high, go low when counter matches.)
1304   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1305   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1306
1307   /*
1308   14.8.3:
1309   "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 [..]."
1310   "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)."
1311   */
1312   TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1313   TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1314   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1315   ICRx = TIMER_TOP;
1316
1317   backlight_init();
1318   #ifdef BACKLIGHT_BREATHING
1319     breathing_enable();
1320   #endif
1321 }
1322
1323 #endif // NO_HARDWARE_PWM
1324
1325 #else // backlight
1326
1327 __attribute__ ((weak))
1328 void backlight_init_ports(void) {}
1329
1330 __attribute__ ((weak))
1331 void backlight_set(uint8_t level) {}
1332
1333 #endif // backlight
1334
1335 #ifdef HD44780_ENABLED
1336 #include "hd44780.h"
1337 #endif
1338
1339
1340 // Functions for spitting out values
1341 //
1342
1343 void send_dword(uint32_t number) { // this might not actually work
1344     uint16_t word = (number >> 16);
1345     send_word(word);
1346     send_word(number & 0xFFFFUL);
1347 }
1348
1349 void send_word(uint16_t number) {
1350     uint8_t byte = number >> 8;
1351     send_byte(byte);
1352     send_byte(number & 0xFF);
1353 }
1354
1355 void send_byte(uint8_t number) {
1356     uint8_t nibble = number >> 4;
1357     send_nibble(nibble);
1358     send_nibble(number & 0xF);
1359 }
1360
1361 void send_nibble(uint8_t number) {
1362     switch (number) {
1363         case 0:
1364             register_code(KC_0);
1365             unregister_code(KC_0);
1366             break;
1367         case 1 ... 9:
1368             register_code(KC_1 + (number - 1));
1369             unregister_code(KC_1 + (number - 1));
1370             break;
1371         case 0xA ... 0xF:
1372             register_code(KC_A + (number - 0xA));
1373             unregister_code(KC_A + (number - 0xA));
1374             break;
1375     }
1376 }
1377
1378
1379 __attribute__((weak))
1380 uint16_t hex_to_keycode(uint8_t hex)
1381 {
1382   hex = hex & 0xF;
1383   if (hex == 0x0) {
1384     return KC_0;
1385   } else if (hex < 0xA) {
1386     return KC_1 + (hex - 0x1);
1387   } else {
1388     return KC_A + (hex - 0xA);
1389   }
1390 }
1391
1392 void api_send_unicode(uint32_t unicode) {
1393 #ifdef API_ENABLE
1394     uint8_t chunk[4];
1395     dword_to_bytes(unicode, chunk);
1396     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1397 #endif
1398 }
1399
1400 __attribute__ ((weak))
1401 void led_set_user(uint8_t usb_led) {
1402
1403 }
1404
1405 __attribute__ ((weak))
1406 void led_set_kb(uint8_t usb_led) {
1407     led_set_user(usb_led);
1408 }
1409
1410 __attribute__ ((weak))
1411 void led_init_ports(void)
1412 {
1413
1414 }
1415
1416 __attribute__ ((weak))
1417 void led_set(uint8_t usb_led)
1418 {
1419
1420   // Example LED Code
1421   //
1422     // // Using PE6 Caps Lock LED
1423     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1424     // {
1425     //     // Output high.
1426     //     DDRE |= (1<<6);
1427     //     PORTE |= (1<<6);
1428     // }
1429     // else
1430     // {
1431     //     // Output low.
1432     //     DDRE &= ~(1<<6);
1433     //     PORTE &= ~(1<<6);
1434     // }
1435
1436   led_set_kb(usb_led);
1437 }
1438
1439
1440 //------------------------------------------------------------------------------
1441 // Override these functions in your keymap file to play different tunes on
1442 // different events such as startup and bootloader jump
1443
1444 __attribute__ ((weak))
1445 void startup_user() {}
1446
1447 __attribute__ ((weak))
1448 void shutdown_user() {}
1449
1450 //------------------------------------------------------------------------------