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