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_NKRO:
 630             keymap_config.nkro = !keymap_config.nkro;
 631             break;
 632           default:
 633             break;
 634         }
 635         eeconfig_update_keymap(keymap_config.raw);
 636         clear_keyboard(); // clear to prevent stuck keys
 637
 638         return false;
 639       }
 640       break;
 641     case KC_LSPO: {
 642       if (record->event.pressed) {
 643         shift_interrupted[0] = false;
 644         scs_timer[0] = timer_read ();
 645         register_mods(MOD_BIT(KC_LSFT));
 646       }
 647       else {
 648         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 649           if (get_mods() & MOD_BIT(KC_RSFT)) {
 650             shift_interrupted[0] = true;
 651             shift_interrupted[1] = true;
 652           }
 653         #endif
 654         if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
 655           register_code(LSPO_KEY);
 656           unregister_code(LSPO_KEY);
 657         }
 658         unregister_mods(MOD_BIT(KC_LSFT));
 659       }
 660       return false;
 661     }
 662
 663     case KC_RSPC: {
 664       if (record->event.pressed) {
 665         shift_interrupted[1] = false;
 666         scs_timer[1] = timer_read ();
 667         register_mods(MOD_BIT(KC_RSFT));
 668       }
 669       else {
 670         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 671           if (get_mods() & MOD_BIT(KC_LSFT)) {
 672             shift_interrupted[0] = true;
 673             shift_interrupted[1] = true;
 674           }
 675         #endif
 676         if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 677           register_code(RSPC_KEY);
 678           unregister_code(RSPC_KEY);
 679         }
 680         unregister_mods(MOD_BIT(KC_RSFT));
 681       }
 682       return false;
 683     }
 684
 685     case KC_SFTENT: {
 686       if (record->event.pressed) {
 687         shift_interrupted[1] = false;
 688         scs_timer[1] = timer_read ();
 689         register_mods(MOD_BIT(KC_RSFT));
 690       }
 691       else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 692         unregister_mods(MOD_BIT(KC_RSFT));
 693         register_code(SFTENT_KEY);
 694         unregister_code(SFTENT_KEY);
 695       }
 696       else {
 697         unregister_mods(MOD_BIT(KC_RSFT));
 698       }
 699       return false;
 700     }
 701
 702     case GRAVE_ESC: {
 703       uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
 704                                       |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
 705
 706 #ifdef GRAVE_ESC_ALT_OVERRIDE
 707       // if ALT is pressed, ESC is always sent
 708       // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 709       if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 710         shifted = 0;
 711       }
 712 #endif
 713
 714 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 715       // if CTRL is pressed, ESC is always sent
 716       // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 717       if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 718         shifted = 0;
 719       }
 720 #endif
 721
 722 #ifdef GRAVE_ESC_GUI_OVERRIDE
 723       // if GUI is pressed, ESC is always sent
 724       if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 725         shifted = 0;
 726       }
 727 #endif
 728
 729 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 730       // if SHIFT is pressed, ESC is always sent
 731       if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 732         shifted = 0;
 733       }
 734 #endif
 735
 736       if (record->event.pressed) {
 737         grave_esc_was_shifted = shifted;
 738         add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 739       }
 740       else {
 741         del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 742       }
 743
 744       send_keyboard_report();
 745       return false;
 746     }
 747
 748 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
 749     case BL_BRTG: {
 750       if (record->event.pressed)
 751         breathing_toggle();
 752       return false;
 753     }
 754 #endif
 755
 756     default: {
 757       shift_interrupted[0] = true;
 758       shift_interrupted[1] = true;
 759       break;
 760     }
 761   }
 762
 763   return process_action_kb(record);
 764 }
 765
 766 __attribute__ ((weak))
 767 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 768     0, 0, 0, 0, 0, 0, 0, 0,
 769     0, 0, 0, 0, 0, 0, 0, 0,
 770     0, 0, 0, 0, 0, 0, 0, 0,
 771     0, 0, 0, 0, 0, 0, 0, 0,
 772     0, 1, 1, 1, 1, 1, 1, 0,
 773     1, 1, 1, 1, 0, 0, 0, 0,
 774     0, 0, 0, 0, 0, 0, 0, 0,
 775     0, 0, 1, 0, 1, 0, 1, 1,
 776     1, 1, 1, 1, 1, 1, 1, 1,
 777     1, 1, 1, 1, 1, 1, 1, 1,
 778     1, 1, 1, 1, 1, 1, 1, 1,
 779     1, 1, 1, 0, 0, 0, 1, 1,
 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, 0, 0, 1, 1, 1, 1, 0
 784 };
 785
 786 __attribute__ ((weak))
 787 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 788     0, 0, 0, 0, 0, 0, 0, 0,
 789     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 790     0, 0, 0, 0, 0, 0, 0, 0,
 791     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 792     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 793     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 794     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 795     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 796     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 797     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 798     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 799     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 800     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 801     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 802     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 803     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 804 };
 805
 806 void send_string(const char *str) {
 807   send_string_with_delay(str, 0);
 808 }
 809
 810 void send_string_P(const char *str) {
 811   send_string_with_delay_P(str, 0);
 812 }
 813
 814 void send_string_with_delay(const char *str, uint8_t interval) {
 815     while (1) {
 816         char ascii_code = *str;
 817         if (!ascii_code) break;
 818         if (ascii_code == 1) {
 819           // tap
 820           uint8_t keycode = *(++str);
 821           register_code(keycode);
 822           unregister_code(keycode);
 823         } else if (ascii_code == 2) {
 824           // down
 825           uint8_t keycode = *(++str);
 826           register_code(keycode);
 827         } else if (ascii_code == 3) {
 828           // up
 829           uint8_t keycode = *(++str);
 830           unregister_code(keycode);
 831         } else {
 832           send_char(ascii_code);
 833         }
 834         ++str;
 835         // interval
 836         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 837     }
 838 }
 839
 840 void send_string_with_delay_P(const char *str, uint8_t interval) {
 841     while (1) {
 842         char ascii_code = pgm_read_byte(str);
 843         if (!ascii_code) break;
 844         if (ascii_code == 1) {
 845           // tap
 846           uint8_t keycode = pgm_read_byte(++str);
 847           register_code(keycode);
 848           unregister_code(keycode);
 849         } else if (ascii_code == 2) {
 850           // down
 851           uint8_t keycode = pgm_read_byte(++str);
 852           register_code(keycode);
 853         } else if (ascii_code == 3) {
 854           // up
 855           uint8_t keycode = pgm_read_byte(++str);
 856           unregister_code(keycode);
 857         } else {
 858           send_char(ascii_code);
 859         }
 860         ++str;
 861         // interval
 862         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 863     }
 864 }
 865
 866 void send_char(char ascii_code) {
 867   uint8_t keycode;
 868   keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 869   if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
 870       register_code(KC_LSFT);
 871       register_code(keycode);
 872       unregister_code(keycode);
 873       unregister_code(KC_LSFT);
 874   } else {
 875       register_code(keycode);
 876       unregister_code(keycode);
 877   }
 878 }
 879
 880 void set_single_persistent_default_layer(uint8_t default_layer) {
 881   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 882     PLAY_SONG(default_layer_songs[default_layer]);
 883   #endif
 884   eeconfig_update_default_layer(1U<<default_layer);
 885   default_layer_set(1U<<default_layer);
 886 }
 887
 888 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 889   uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
 890   uint32_t mask3 = 1UL << layer3;
 891   return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
 892 }
 893
 894 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 895   layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
 896 }
 897
 898 void tap_random_base64(void) {
 899   #if defined(__AVR_ATmega32U4__)
 900     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 901   #else
 902     uint8_t key = rand() % 64;
 903   #endif
 904   switch (key) {
 905     case 0 ... 25:
 906       register_code(KC_LSFT);
 907       register_code(key + KC_A);
 908       unregister_code(key + KC_A);
 909       unregister_code(KC_LSFT);
 910       break;
 911     case 26 ... 51:
 912       register_code(key - 26 + KC_A);
 913       unregister_code(key - 26 + KC_A);
 914       break;
 915     case 52:
 916       register_code(KC_0);
 917       unregister_code(KC_0);
 918       break;
 919     case 53 ... 61:
 920       register_code(key - 53 + KC_1);
 921       unregister_code(key - 53 + KC_1);
 922       break;
 923     case 62:
 924       register_code(KC_LSFT);
 925       register_code(KC_EQL);
 926       unregister_code(KC_EQL);
 927       unregister_code(KC_LSFT);
 928       break;
 929     case 63:
 930       register_code(KC_SLSH);
 931       unregister_code(KC_SLSH);
 932       break;
 933   }
 934 }
 935
 936 void matrix_init_quantum() {
 937   #ifdef BACKLIGHT_ENABLE
 938     backlight_init_ports();
 939   #endif
 940   #ifdef AUDIO_ENABLE
 941     audio_init();
 942   #endif
 943   #ifdef RGB_MATRIX_ENABLE
 944     rgb_matrix_init();
 945   #endif
 946   matrix_init_kb();
 947 }
 948
 949 uint8_t rgb_matrix_task_counter = 0;
 950
 951 #ifndef RGB_MATRIX_SKIP_FRAMES
 952   #define RGB_MATRIX_SKIP_FRAMES 1
 953 #endif
 954
 955 void matrix_scan_quantum() {
 956   #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
 957     matrix_scan_music();
 958   #endif
 959
 960   #ifdef TAP_DANCE_ENABLE
 961     matrix_scan_tap_dance();
 962   #endif
 963
 964   #ifdef COMBO_ENABLE
 965     matrix_scan_combo();
 966   #endif
 967
 968   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 969     backlight_task();
 970   #endif
 971
 972   #ifdef RGB_MATRIX_ENABLE
 973     rgb_matrix_task();
 974     if (rgb_matrix_task_counter == 0) {
 975       rgb_matrix_update_pwm_buffers();
 976     }
 977     rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
 978   #endif
 979
 980   matrix_scan_kb();
 981 }
 982 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 983
 984 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 985
 986 // depending on the pin, we use a different output compare unit
 987 #if BACKLIGHT_PIN == B7
 988 #  define TCCRxA TCCR1A
 989 #  define TCCRxB TCCR1B
 990 #  define COMxx1 COM1C1
 991 #  define OCRxx  OCR1C
 992 #  define ICRx   ICR1
 993 #elif BACKLIGHT_PIN == B6
 994 #  define TCCRxA TCCR1A
 995 #  define TCCRxB TCCR1B
 996 #  define COMxx1 COM1B1
 997 #  define OCRxx  OCR1B
 998 #  define ICRx   ICR1
 999 #elif BACKLIGHT_PIN == B5
1000 #  define TCCRxA TCCR1A
1001 #  define TCCRxB TCCR1B
1002 #  define COMxx1 COM1A1
1003 #  define OCRxx  OCR1A
1004 #  define ICRx   ICR1
1005 #elif BACKLIGHT_PIN == C6
1006 #  define TCCRxA TCCR3A
1007 #  define TCCRxB TCCR3B
1008 #  define COMxx1 COM1A1
1009 #  define OCRxx  OCR3A
1010 #  define ICRx   ICR3
1011 #else
1012 #  define NO_HARDWARE_PWM
1013 #endif
1014
1015 #ifndef BACKLIGHT_ON_STATE
1016 #define BACKLIGHT_ON_STATE 0
1017 #endif
1018
1019 #ifdef NO_HARDWARE_PWM // pwm through software
1020
1021 __attribute__ ((weak))
1022 void backlight_init_ports(void)
1023 {
1024   // Setup backlight pin as output and output to on state.
1025   // DDRx |= n
1026   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1027   #if BACKLIGHT_ON_STATE == 0
1028     // PORTx &= ~n
1029     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1030   #else
1031     // PORTx |= n
1032     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1033   #endif
1034 }
1035
1036 __attribute__ ((weak))
1037 void backlight_set(uint8_t level) {}
1038
1039 uint8_t backlight_tick = 0;
1040
1041 #ifndef BACKLIGHT_CUSTOM_DRIVER
1042 void backlight_task(void) {
1043   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1044     #if BACKLIGHT_ON_STATE == 0
1045       // PORTx &= ~n
1046       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1047     #else
1048       // PORTx |= n
1049       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1050     #endif
1051   } else {
1052     #if BACKLIGHT_ON_STATE == 0
1053       // PORTx |= n
1054       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1055     #else
1056       // PORTx &= ~n
1057       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1058     #endif
1059   }
1060   backlight_tick = (backlight_tick + 1) % 16;
1061 }
1062 #endif
1063
1064 #ifdef BACKLIGHT_BREATHING
1065   #ifndef BACKLIGHT_CUSTOM_DRIVER
1066   #error "Backlight breathing only available with hardware PWM. Please disable."
1067   #endif
1068 #endif
1069
1070 #else // pwm through timer
1071
1072 #define TIMER_TOP 0xFFFFU
1073
1074 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1075 static uint16_t cie_lightness(uint16_t v) {
1076   if (v <= 5243) // if below 8% of max
1077     return v / 9; // same as dividing by 900%
1078   else {
1079     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1080     // to get a useful result with integer division, we shift left in the expression above
1081     // and revert what we've done again after squaring.
1082     y = y * y * y >> 8;
1083     if (y > 0xFFFFUL) // prevent overflow
1084       return 0xFFFFU;
1085     else
1086       return (uint16_t) y;
1087   }
1088 }
1089
1090 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1091 static inline void set_pwm(uint16_t val) {
1092         OCRxx = val;
1093 }
1094
1095 #ifndef BACKLIGHT_CUSTOM_DRIVER
1096 __attribute__ ((weak))
1097 void backlight_set(uint8_t level) {
1098   if (level > BACKLIGHT_LEVELS)
1099     level = BACKLIGHT_LEVELS;
1100
1101   if (level == 0) {
1102     // Turn off PWM control on backlight pin
1103     TCCRxA &= ~(_BV(COMxx1));
1104   } else {
1105     // Turn on PWM control of backlight pin
1106     TCCRxA |= _BV(COMxx1);
1107   }
1108   // Set the brightness
1109   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1110 }
1111
1112 void backlight_task(void) {}
1113 #endif  // BACKLIGHT_CUSTOM_DRIVER
1114
1115 #ifdef BACKLIGHT_BREATHING
1116
1117 #define BREATHING_NO_HALT  0
1118 #define BREATHING_HALT_OFF 1
1119 #define BREATHING_HALT_ON  2
1120 #define BREATHING_STEPS 128
1121
1122 static uint8_t breathing_period = BREATHING_PERIOD;
1123 static uint8_t breathing_halt = BREATHING_NO_HALT;
1124 static uint16_t breathing_counter = 0;
1125
1126 bool is_breathing(void) {
1127     return !!(TIMSK1 & _BV(TOIE1));
1128 }
1129
1130 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1131 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1132 #define breathing_min() do {breathing_counter = 0;} while (0)
1133 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1134
1135 void breathing_enable(void)
1136 {
1137   breathing_counter = 0;
1138   breathing_halt = BREATHING_NO_HALT;
1139   breathing_interrupt_enable();
1140 }
1141
1142 void breathing_pulse(void)
1143 {
1144     if (get_backlight_level() == 0)
1145       breathing_min();
1146     else
1147       breathing_max();
1148     breathing_halt = BREATHING_HALT_ON;
1149     breathing_interrupt_enable();
1150 }
1151
1152 void breathing_disable(void)
1153 {
1154     breathing_interrupt_disable();
1155     // Restore backlight level
1156     backlight_set(get_backlight_level());
1157 }
1158
1159 void breathing_self_disable(void)
1160 {
1161   if (get_backlight_level() == 0)
1162     breathing_halt = BREATHING_HALT_OFF;
1163   else
1164     breathing_halt = BREATHING_HALT_ON;
1165 }
1166
1167 void breathing_toggle(void) {
1168   if (is_breathing())
1169     breathing_disable();
1170   else
1171     breathing_enable();
1172 }
1173
1174 void breathing_period_set(uint8_t value)
1175 {
1176   if (!value)
1177     value = 1;
1178   breathing_period = value;
1179 }
1180
1181 void breathing_period_default(void) {
1182   breathing_period_set(BREATHING_PERIOD);
1183 }
1184
1185 void breathing_period_inc(void)
1186 {
1187   breathing_period_set(breathing_period+1);
1188 }
1189
1190 void breathing_period_dec(void)
1191 {
1192   breathing_period_set(breathing_period-1);
1193 }
1194
1195 /* To generate breathing curve in python:
1196  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1197  */
1198 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};
1199
1200 // Use this before the cie_lightness function.
1201 static inline uint16_t scale_backlight(uint16_t v) {
1202   return v / BACKLIGHT_LEVELS * get_backlight_level();
1203 }
1204
1205 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1206  * about 244 times per second.
1207  */
1208 ISR(TIMER1_OVF_vect)
1209 {
1210   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1211   // resetting after one period to prevent ugly reset at overflow.
1212   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1213   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1214
1215   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1216       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1217   {
1218       breathing_interrupt_disable();
1219   }
1220
1221   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1222 }
1223
1224 #endif // BACKLIGHT_BREATHING
1225
1226 __attribute__ ((weak))
1227 void backlight_init_ports(void)
1228 {
1229   // Setup backlight pin as output and output to on state.
1230   // DDRx |= n
1231   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1232   #if BACKLIGHT_ON_STATE == 0
1233     // PORTx &= ~n
1234     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1235   #else
1236     // PORTx |= n
1237     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1238   #endif
1239   // I could write a wall of text here to explain... but TL;DW
1240   // Go read the ATmega32u4 datasheet.
1241   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1242
1243   // Pin PB7 = OCR1C (Timer 1, Channel C)
1244   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1245   // (i.e. start high, go low when counter matches.)
1246   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1247   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1248
1249   /*
1250   14.8.3:
1251   "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 [..]."
1252   "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)."
1253   */
1254   TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1255   TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1256   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1257   ICRx = TIMER_TOP;
1258
1259   backlight_init();
1260   #ifdef BACKLIGHT_BREATHING
1261     breathing_enable();
1262   #endif
1263 }
1264
1265 #endif // NO_HARDWARE_PWM
1266
1267 #else // backlight
1268
1269 __attribute__ ((weak))
1270 void backlight_init_ports(void) {}
1271
1272 __attribute__ ((weak))
1273 void backlight_set(uint8_t level) {}
1274
1275 #endif // backlight
1276
1277 #ifdef HD44780_ENABLED
1278 #include "hd44780.h"
1279 #endif
1280
1281
1282 // Functions for spitting out values
1283 //
1284
1285 void send_dword(uint32_t number) { // this might not actually work
1286     uint16_t word = (number >> 16);
1287     send_word(word);
1288     send_word(number & 0xFFFFUL);
1289 }
1290
1291 void send_word(uint16_t number) {
1292     uint8_t byte = number >> 8;
1293     send_byte(byte);
1294     send_byte(number & 0xFF);
1295 }
1296
1297 void send_byte(uint8_t number) {
1298     uint8_t nibble = number >> 4;
1299     send_nibble(nibble);
1300     send_nibble(number & 0xF);
1301 }
1302
1303 void send_nibble(uint8_t number) {
1304     switch (number) {
1305         case 0:
1306             register_code(KC_0);
1307             unregister_code(KC_0);
1308             break;
1309         case 1 ... 9:
1310             register_code(KC_1 + (number - 1));
1311             unregister_code(KC_1 + (number - 1));
1312             break;
1313         case 0xA ... 0xF:
1314             register_code(KC_A + (number - 0xA));
1315             unregister_code(KC_A + (number - 0xA));
1316             break;
1317     }
1318 }
1319
1320
1321 __attribute__((weak))
1322 uint16_t hex_to_keycode(uint8_t hex)
1323 {
1324   hex = hex & 0xF;
1325   if (hex == 0x0) {
1326     return KC_0;
1327   } else if (hex < 0xA) {
1328     return KC_1 + (hex - 0x1);
1329   } else {
1330     return KC_A + (hex - 0xA);
1331   }
1332 }
1333
1334 void api_send_unicode(uint32_t unicode) {
1335 #ifdef API_ENABLE
1336     uint8_t chunk[4];
1337     dword_to_bytes(unicode, chunk);
1338     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1339 #endif
1340 }
1341
1342 __attribute__ ((weak))
1343 void led_set_user(uint8_t usb_led) {
1344
1345 }
1346
1347 __attribute__ ((weak))
1348 void led_set_kb(uint8_t usb_led) {
1349     led_set_user(usb_led);
1350 }
1351
1352 __attribute__ ((weak))
1353 void led_init_ports(void)
1354 {
1355
1356 }
1357
1358 __attribute__ ((weak))
1359 void led_set(uint8_t usb_led)
1360 {
1361
1362   // Example LED Code
1363   //
1364     // // Using PE6 Caps Lock LED
1365     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1366     // {
1367     //     // Output high.
1368     //     DDRE |= (1<<6);
1369     //     PORTE |= (1<<6);
1370     // }
1371     // else
1372     // {
1373     //     // Output low.
1374     //     DDRE &= ~(1<<6);
1375     //     PORTE &= ~(1<<6);
1376     // }
1377
1378   led_set_kb(usb_led);
1379 }
1380
1381
1382 //------------------------------------------------------------------------------
1383 // Override these functions in your keymap file to play different tunes on
1384 // different events such as startup and bootloader jump
1385
1386 __attribute__ ((weak))
1387 void startup_user() {}
1388
1389 __attribute__ ((weak))
1390 void shutdown_user() {}
1391
1392 //------------------------------------------------------------------------------