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     #ifdef LED_MATRIX_ENABLE
1035         led_matrix_init();
1036     #else
1037         backlight_init_ports();
1038     #endif
1039   #endif
1040   #ifdef AUDIO_ENABLE
1041     audio_init();
1042   #endif
1043   #ifdef RGB_MATRIX_ENABLE
1044     rgb_matrix_init();
1045   #endif
1046   #ifdef ENCODER_ENABLE
1047     encoder_init();
1048   #endif
1049   #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1050     unicode_input_mode_init();
1051   #endif
1052   matrix_init_kb();
1053 }
1054
1055 uint8_t rgb_matrix_task_counter = 0;
1056
1057 #ifndef RGB_MATRIX_SKIP_FRAMES
1058   #define RGB_MATRIX_SKIP_FRAMES 1
1059 #endif
1060
1061 void matrix_scan_quantum() {
1062   #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1063     matrix_scan_music();
1064   #endif
1065
1066   #ifdef TAP_DANCE_ENABLE
1067     matrix_scan_tap_dance();
1068   #endif
1069
1070   #ifdef COMBO_ENABLE
1071     matrix_scan_combo();
1072   #endif
1073
1074   #if defined(BACKLIGHT_ENABLE)
1075     #if defined(LED_MATRIX_ENABLE)
1076         led_matrix_task();
1077     #elif defined(BACKLIGHT_PIN)
1078         backlight_task();
1079     #endif
1080   #endif
1081
1082   #ifdef RGB_MATRIX_ENABLE
1083     rgb_matrix_task();
1084     if (rgb_matrix_task_counter == 0) {
1085       rgb_matrix_update_pwm_buffers();
1086     }
1087     rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
1088   #endif
1089
1090   #ifdef ENCODER_ENABLE
1091     encoder_read();
1092   #endif
1093
1094   matrix_scan_kb();
1095 }
1096 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1097
1098 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1099
1100 // depending on the pin, we use a different output compare unit
1101 #if BACKLIGHT_PIN == B7
1102 #  define TCCRxA TCCR1A
1103 #  define TCCRxB TCCR1B
1104 #  define COMxx1 COM1C1
1105 #  define OCRxx  OCR1C
1106 #  define ICRx   ICR1
1107 #elif BACKLIGHT_PIN == B6
1108 #  define TCCRxA TCCR1A
1109 #  define TCCRxB TCCR1B
1110 #  define COMxx1 COM1B1
1111 #  define OCRxx  OCR1B
1112 #  define ICRx   ICR1
1113 #elif BACKLIGHT_PIN == B5
1114 #  define TCCRxA TCCR1A
1115 #  define TCCRxB TCCR1B
1116 #  define COMxx1 COM1A1
1117 #  define OCRxx  OCR1A
1118 #  define ICRx   ICR1
1119 #elif BACKLIGHT_PIN == C6
1120 #  define TCCRxA TCCR3A
1121 #  define TCCRxB TCCR3B
1122 #  define COMxx1 COM1A1
1123 #  define OCRxx  OCR3A
1124 #  define ICRx   ICR3
1125 #else
1126 #  define NO_HARDWARE_PWM
1127 #endif
1128
1129 #ifndef BACKLIGHT_ON_STATE
1130 #define BACKLIGHT_ON_STATE 0
1131 #endif
1132
1133 #ifdef NO_HARDWARE_PWM // pwm through software
1134
1135 __attribute__ ((weak))
1136 void backlight_init_ports(void)
1137 {
1138   // Setup backlight pin as output and output to on state.
1139   // DDRx |= n
1140   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1141   #if BACKLIGHT_ON_STATE == 0
1142     // PORTx &= ~n
1143     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1144   #else
1145     // PORTx |= n
1146     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1147   #endif
1148 }
1149
1150 __attribute__ ((weak))
1151 void backlight_set(uint8_t level) {}
1152
1153 uint8_t backlight_tick = 0;
1154
1155 #ifndef BACKLIGHT_CUSTOM_DRIVER
1156 void backlight_task(void) {
1157   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
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   } else {
1166     #if BACKLIGHT_ON_STATE == 0
1167       // PORTx |= n
1168       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1169     #else
1170       // PORTx &= ~n
1171       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1172     #endif
1173   }
1174   backlight_tick = (backlight_tick + 1) % 16;
1175 }
1176 #endif
1177
1178 #ifdef BACKLIGHT_BREATHING
1179   #ifndef BACKLIGHT_CUSTOM_DRIVER
1180   #error "Backlight breathing only available with hardware PWM. Please disable."
1181   #endif
1182 #endif
1183
1184 #else // pwm through timer
1185
1186 #define TIMER_TOP 0xFFFFU
1187
1188 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1189 static uint16_t cie_lightness(uint16_t v) {
1190   if (v <= 5243) // if below 8% of max
1191     return v / 9; // same as dividing by 900%
1192   else {
1193     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1194     // to get a useful result with integer division, we shift left in the expression above
1195     // and revert what we've done again after squaring.
1196     y = y * y * y >> 8;
1197     if (y > 0xFFFFUL) // prevent overflow
1198       return 0xFFFFU;
1199     else
1200       return (uint16_t) y;
1201   }
1202 }
1203
1204 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1205 static inline void set_pwm(uint16_t val) {
1206         OCRxx = val;
1207 }
1208
1209 #ifndef BACKLIGHT_CUSTOM_DRIVER
1210 __attribute__ ((weak))
1211 void backlight_set(uint8_t level) {
1212   if (level > BACKLIGHT_LEVELS)
1213     level = BACKLIGHT_LEVELS;
1214
1215   if (level == 0) {
1216     // Turn off PWM control on backlight pin
1217     TCCRxA &= ~(_BV(COMxx1));
1218   } else {
1219     // Turn on PWM control of backlight pin
1220     TCCRxA |= _BV(COMxx1);
1221   }
1222   // Set the brightness
1223   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1224 }
1225
1226 void backlight_task(void) {}
1227 #endif  // BACKLIGHT_CUSTOM_DRIVER
1228
1229 #ifdef BACKLIGHT_BREATHING
1230
1231 #define BREATHING_NO_HALT  0
1232 #define BREATHING_HALT_OFF 1
1233 #define BREATHING_HALT_ON  2
1234 #define BREATHING_STEPS 128
1235
1236 static uint8_t breathing_period = BREATHING_PERIOD;
1237 static uint8_t breathing_halt = BREATHING_NO_HALT;
1238 static uint16_t breathing_counter = 0;
1239
1240 bool is_breathing(void) {
1241     return !!(TIMSK1 & _BV(TOIE1));
1242 }
1243
1244 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1245 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1246 #define breathing_min() do {breathing_counter = 0;} while (0)
1247 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1248
1249 void breathing_enable(void)
1250 {
1251   breathing_counter = 0;
1252   breathing_halt = BREATHING_NO_HALT;
1253   breathing_interrupt_enable();
1254 }
1255
1256 void breathing_pulse(void)
1257 {
1258     if (get_backlight_level() == 0)
1259       breathing_min();
1260     else
1261       breathing_max();
1262     breathing_halt = BREATHING_HALT_ON;
1263     breathing_interrupt_enable();
1264 }
1265
1266 void breathing_disable(void)
1267 {
1268     breathing_interrupt_disable();
1269     // Restore backlight level
1270     backlight_set(get_backlight_level());
1271 }
1272
1273 void breathing_self_disable(void)
1274 {
1275   if (get_backlight_level() == 0)
1276     breathing_halt = BREATHING_HALT_OFF;
1277   else
1278     breathing_halt = BREATHING_HALT_ON;
1279 }
1280
1281 void breathing_toggle(void) {
1282   if (is_breathing())
1283     breathing_disable();
1284   else
1285     breathing_enable();
1286 }
1287
1288 void breathing_period_set(uint8_t value)
1289 {
1290   if (!value)
1291     value = 1;
1292   breathing_period = value;
1293 }
1294
1295 void breathing_period_default(void) {
1296   breathing_period_set(BREATHING_PERIOD);
1297 }
1298
1299 void breathing_period_inc(void)
1300 {
1301   breathing_period_set(breathing_period+1);
1302 }
1303
1304 void breathing_period_dec(void)
1305 {
1306   breathing_period_set(breathing_period-1);
1307 }
1308
1309 /* To generate breathing curve in python:
1310  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1311  */
1312 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};
1313
1314 // Use this before the cie_lightness function.
1315 static inline uint16_t scale_backlight(uint16_t v) {
1316   return v / BACKLIGHT_LEVELS * get_backlight_level();
1317 }
1318
1319 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1320  * about 244 times per second.
1321  */
1322 ISR(TIMER1_OVF_vect)
1323 {
1324   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1325   // resetting after one period to prevent ugly reset at overflow.
1326   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1327   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1328
1329   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1330       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1331   {
1332       breathing_interrupt_disable();
1333   }
1334
1335   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1336 }
1337
1338 #endif // BACKLIGHT_BREATHING
1339
1340 __attribute__ ((weak))
1341 void backlight_init_ports(void)
1342 {
1343   // Setup backlight pin as output and output to on state.
1344   // DDRx |= n
1345   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1346   #if BACKLIGHT_ON_STATE == 0
1347     // PORTx &= ~n
1348     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1349   #else
1350     // PORTx |= n
1351     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1352   #endif
1353   // I could write a wall of text here to explain... but TL;DW
1354   // Go read the ATmega32u4 datasheet.
1355   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1356
1357   // Pin PB7 = OCR1C (Timer 1, Channel C)
1358   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1359   // (i.e. start high, go low when counter matches.)
1360   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1361   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1362
1363   /*
1364   14.8.3:
1365   "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 [..]."
1366   "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)."
1367   */
1368   TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1369   TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1370   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1371   ICRx = TIMER_TOP;
1372
1373   backlight_init();
1374   #ifdef BACKLIGHT_BREATHING
1375     breathing_enable();
1376   #endif
1377 }
1378
1379 #endif // NO_HARDWARE_PWM
1380
1381 #else // backlight
1382
1383 __attribute__ ((weak))
1384 void backlight_init_ports(void) {}
1385
1386 __attribute__ ((weak))
1387 void backlight_set(uint8_t level) {}
1388
1389 #endif // backlight
1390
1391 #ifdef HD44780_ENABLED
1392 #include "hd44780.h"
1393 #endif
1394
1395
1396 // Functions for spitting out values
1397 //
1398
1399 void send_dword(uint32_t number) { // this might not actually work
1400     uint16_t word = (number >> 16);
1401     send_word(word);
1402     send_word(number & 0xFFFFUL);
1403 }
1404
1405 void send_word(uint16_t number) {
1406     uint8_t byte = number >> 8;
1407     send_byte(byte);
1408     send_byte(number & 0xFF);
1409 }
1410
1411 void send_byte(uint8_t number) {
1412     uint8_t nibble = number >> 4;
1413     send_nibble(nibble);
1414     send_nibble(number & 0xF);
1415 }
1416
1417 void send_nibble(uint8_t number) {
1418     switch (number) {
1419         case 0:
1420             register_code(KC_0);
1421             unregister_code(KC_0);
1422             break;
1423         case 1 ... 9:
1424             register_code(KC_1 + (number - 1));
1425             unregister_code(KC_1 + (number - 1));
1426             break;
1427         case 0xA ... 0xF:
1428             register_code(KC_A + (number - 0xA));
1429             unregister_code(KC_A + (number - 0xA));
1430             break;
1431     }
1432 }
1433
1434
1435 __attribute__((weak))
1436 uint16_t hex_to_keycode(uint8_t hex)
1437 {
1438   hex = hex & 0xF;
1439   if (hex == 0x0) {
1440     return KC_0;
1441   } else if (hex < 0xA) {
1442     return KC_1 + (hex - 0x1);
1443   } else {
1444     return KC_A + (hex - 0xA);
1445   }
1446 }
1447
1448 void api_send_unicode(uint32_t unicode) {
1449 #ifdef API_ENABLE
1450     uint8_t chunk[4];
1451     dword_to_bytes(unicode, chunk);
1452     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1453 #endif
1454 }
1455
1456 __attribute__ ((weak))
1457 void led_set_user(uint8_t usb_led) {
1458
1459 }
1460
1461 __attribute__ ((weak))
1462 void led_set_kb(uint8_t usb_led) {
1463     led_set_user(usb_led);
1464 }
1465
1466 __attribute__ ((weak))
1467 void led_init_ports(void)
1468 {
1469
1470 }
1471
1472 __attribute__ ((weak))
1473 void led_set(uint8_t usb_led)
1474 {
1475
1476   // Example LED Code
1477   //
1478     // // Using PE6 Caps Lock LED
1479     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1480     // {
1481     //     // Output high.
1482     //     DDRE |= (1<<6);
1483     //     PORTE |= (1<<6);
1484     // }
1485     // else
1486     // {
1487     //     // Output low.
1488     //     DDRE &= ~(1<<6);
1489     //     PORTE &= ~(1<<6);
1490     // }
1491
1492 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1493   // Use backlight as Caps Lock indicator
1494   uint8_t bl_toggle_lvl = 0;
1495
1496   if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1497     // Turning Caps Lock ON and backlight is disabled in config
1498     // Toggling backlight to the brightest level
1499     bl_toggle_lvl = BACKLIGHT_LEVELS;
1500   } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1501     // Turning Caps Lock OFF and backlight is enabled in config
1502     // Toggling backlight and restoring config level
1503     bl_toggle_lvl = backlight_config.level;
1504   }
1505
1506   // Set level without modify backlight_config to keep ability to restore state
1507   backlight_set(bl_toggle_lvl);
1508 #endif
1509
1510   led_set_kb(usb_led);
1511 }
1512
1513
1514 //------------------------------------------------------------------------------
1515 // Override these functions in your keymap file to play different tunes on
1516 // different events such as startup and bootloader jump
1517
1518 __attribute__ ((weak))
1519 void startup_user() {}
1520
1521 __attribute__ ((weak))
1522 void shutdown_user() {}
1523
1524 //------------------------------------------------------------------------------