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