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