quantum/quantum.c

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