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