quantum/quantum.c

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