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