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