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