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