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 #include "backlight.h"
  27 extern backlight_config_t backlight_config;
  28
  29 #ifdef FAUXCLICKY_ENABLE
  30 #include "fauxclicky.h"
  31 #endif
  32
  33 #ifdef AUDIO_ENABLE
  34   #ifndef GOODBYE_SONG
  35     #define GOODBYE_SONG SONG(GOODBYE_SOUND)
  36   #endif
  37   #ifndef AG_NORM_SONG
  38     #define AG_NORM_SONG SONG(AG_NORM_SOUND)
  39   #endif
  40   #ifndef AG_SWAP_SONG
  41     #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
  42   #endif
  43   float goodbye_song[][2] = GOODBYE_SONG;
  44   float ag_norm_song[][2] = AG_NORM_SONG;
  45   float ag_swap_song[][2] = AG_SWAP_SONG;
  46   #ifdef DEFAULT_LAYER_SONGS
  47     float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
  48   #endif
  49 #endif
  50
  51 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
  52   switch (code) {
  53   case QK_MODS ... QK_MODS_MAX:
  54     break;
  55   default:
  56     return;
  57   }
  58
  59   if (code & QK_LCTL)
  60     f(KC_LCTL);
  61   if (code & QK_LSFT)
  62     f(KC_LSFT);
  63   if (code & QK_LALT)
  64     f(KC_LALT);
  65   if (code & QK_LGUI)
  66     f(KC_LGUI);
  67
  68   if (code < QK_RMODS_MIN) return;
  69
  70   if (code & QK_RCTL)
  71     f(KC_RCTL);
  72   if (code & QK_RSFT)
  73     f(KC_RSFT);
  74   if (code & QK_RALT)
  75     f(KC_RALT);
  76   if (code & QK_RGUI)
  77     f(KC_RGUI);
  78 }
  79
  80 static inline void qk_register_weak_mods(uint8_t kc) {
  81     add_weak_mods(MOD_BIT(kc));
  82     send_keyboard_report();
  83 }
  84
  85 static inline void qk_unregister_weak_mods(uint8_t kc) {
  86     del_weak_mods(MOD_BIT(kc));
  87     send_keyboard_report();
  88 }
  89
  90 static inline void qk_register_mods(uint8_t kc) {
  91     add_weak_mods(MOD_BIT(kc));
  92     send_keyboard_report();
  93 }
  94
  95 static inline void qk_unregister_mods(uint8_t kc) {
  96     del_weak_mods(MOD_BIT(kc));
  97     send_keyboard_report();
  98 }
  99
 100 void register_code16 (uint16_t code) {
 101   if (IS_MOD(code) || code == KC_NO) {
 102       do_code16 (code, qk_register_mods);
 103   } else {
 104       do_code16 (code, qk_register_weak_mods);
 105   }
 106   register_code (code);
 107 }
 108
 109 void unregister_code16 (uint16_t code) {
 110   unregister_code (code);
 111   if (IS_MOD(code) || code == KC_NO) {
 112       do_code16 (code, qk_unregister_mods);
 113   } else {
 114       do_code16 (code, qk_unregister_weak_mods);
 115   }
 116 }
 117
 118 __attribute__ ((weak))
 119 bool process_action_kb(keyrecord_t *record) {
 120   return true;
 121 }
 122
 123 __attribute__ ((weak))
 124 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
 125   return process_record_user(keycode, record);
 126 }
 127
 128 __attribute__ ((weak))
 129 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 130   return true;
 131 }
 132
 133 void reset_keyboard(void) {
 134   clear_keyboard();
 135 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
 136   music_all_notes_off();
 137   uint16_t timer_start = timer_read();
 138   PLAY_SONG(goodbye_song);
 139   shutdown_user();
 140   while(timer_elapsed(timer_start) < 250)
 141     wait_ms(1);
 142   stop_all_notes();
 143 #else
 144   wait_ms(250);
 145 #endif
 146 #ifdef CATERINA_BOOTLOADER
 147   *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
 148 #endif
 149   bootloader_jump();
 150 }
 151
 152 // Shift / paren setup
 153
 154 #ifndef LSPO_KEY
 155   #define LSPO_KEY KC_9
 156 #endif
 157 #ifndef RSPC_KEY
 158   #define RSPC_KEY KC_0
 159 #endif
 160
 161 static bool shift_interrupted[2] = {0, 0};
 162 static uint16_t scs_timer[2] = {0, 0};
 163
 164 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
 165  * Used to ensure that the correct keycode is released if the key is released.
 166  */
 167 static bool grave_esc_was_shifted = false;
 168
 169 bool process_record_quantum(keyrecord_t *record) {
 170
 171   /* This gets the keycode from the key pressed */
 172   keypos_t key = record->event.key;
 173   uint16_t keycode;
 174
 175   #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
 176     /* TODO: Use store_or_get_action() or a similar function. */
 177     if (!disable_action_cache) {
 178       uint8_t layer;
 179
 180       if (record->event.pressed) {
 181         layer = layer_switch_get_layer(key);
 182         update_source_layers_cache(key, layer);
 183       } else {
 184         layer = read_source_layers_cache(key);
 185       }
 186       keycode = keymap_key_to_keycode(layer, key);
 187     } else
 188   #endif
 189     keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
 190
 191     // This is how you use actions here
 192     // if (keycode == KC_LEAD) {
 193     //   action_t action;
 194     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
 195     //   process_action(record, action);
 196     //   return false;
 197     // }
 198
 199   if (!(
 200   #if defined(KEY_LOCK_ENABLE)
 201     // Must run first to be able to mask key_up events.
 202     process_key_lock(&keycode, record) &&
 203   #endif
 204     process_record_kb(keycode, record) &&
 205   #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
 206     process_midi(keycode, record) &&
 207   #endif
 208   #ifdef AUDIO_ENABLE
 209     process_audio(keycode, record) &&
 210   #endif
 211   #ifdef STENO_ENABLE
 212     process_steno(keycode, record) &&
 213   #endif
 214   #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
 215     process_music(keycode, record) &&
 216   #endif
 217   #ifdef TAP_DANCE_ENABLE
 218     process_tap_dance(keycode, record) &&
 219   #endif
 220   #ifndef DISABLE_LEADER
 221     process_leader(keycode, record) &&
 222   #endif
 223   #ifndef DISABLE_CHORDING
 224     process_chording(keycode, record) &&
 225   #endif
 226   #ifdef COMBO_ENABLE
 227     process_combo(keycode, record) &&
 228   #endif
 229   #ifdef UNICODE_ENABLE
 230     process_unicode(keycode, record) &&
 231   #endif
 232   #ifdef UCIS_ENABLE
 233     process_ucis(keycode, record) &&
 234   #endif
 235   #ifdef PRINTING_ENABLE
 236     process_printer(keycode, record) &&
 237   #endif
 238   #ifdef AUTO_SHIFT_ENABLE
 239     process_auto_shift(keycode, record) &&
 240   #endif
 241   #ifdef UNICODEMAP_ENABLE
 242     process_unicode_map(keycode, record) &&
 243   #endif
 244   #ifdef TERMINAL_ENABLE
 245     process_terminal(keycode, record) &&
 246   #endif
 247       true)) {
 248     return false;
 249   }
 250
 251   // Shift / paren setup
 252
 253   switch(keycode) {
 254     case RESET:
 255       if (record->event.pressed) {
 256         reset_keyboard();
 257       }
 258     return false;
 259     case DEBUG:
 260       if (record->event.pressed) {
 261           debug_enable = true;
 262           print("DEBUG: enabled.\n");
 263       }
 264     return false;
 265   #ifdef FAUXCLICKY_ENABLE
 266   case FC_TOG:
 267     if (record->event.pressed) {
 268       FAUXCLICKY_TOGGLE;
 269     }
 270     return false;
 271   case FC_ON:
 272     if (record->event.pressed) {
 273       FAUXCLICKY_ON;
 274     }
 275     return false;
 276   case FC_OFF:
 277     if (record->event.pressed) {
 278       FAUXCLICKY_OFF;
 279     }
 280     return false;
 281   #endif
 282   #ifdef RGBLIGHT_ENABLE
 283   case RGB_TOG:
 284     if (record->event.pressed) {
 285       rgblight_toggle();
 286     }
 287     return false;
 288   case RGB_MOD:
 289     if (record->event.pressed) {
 290       rgblight_step();
 291     }
 292     return false;
 293   case RGB_SMOD:
 294     // same as RBG_MOD, but if shift is pressed, it will use the reverese direction instead.
 295     if (record->event.pressed) {
 296       uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
 297       if(shifted) {
 298         rgblight_step_reverse();
 299       }
 300       else {
 301         rgblight_step();
 302       }
 303     }
 304     return false;
 305   case RGB_HUI:
 306     if (record->event.pressed) {
 307       rgblight_increase_hue();
 308     }
 309     return false;
 310   case RGB_HUD:
 311     if (record->event.pressed) {
 312       rgblight_decrease_hue();
 313     }
 314     return false;
 315   case RGB_SAI:
 316     if (record->event.pressed) {
 317       rgblight_increase_sat();
 318     }
 319     return false;
 320   case RGB_SAD:
 321     if (record->event.pressed) {
 322       rgblight_decrease_sat();
 323     }
 324     return false;
 325   case RGB_VAI:
 326     if (record->event.pressed) {
 327       rgblight_increase_val();
 328     }
 329     return false;
 330   case RGB_VAD:
 331     if (record->event.pressed) {
 332       rgblight_decrease_val();
 333     }
 334     return false;
 335   case RGB_MODE_PLAIN:
 336     if (record->event.pressed) {
 337       rgblight_mode(1);
 338     }
 339     return false;
 340   case RGB_MODE_BREATHE:
 341     if (record->event.pressed) {
 342       if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
 343         rgblight_step();
 344       } else {
 345         rgblight_mode(2);
 346       }
 347     }
 348     return false;
 349   case RGB_MODE_RAINBOW:
 350     if (record->event.pressed) {
 351       if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
 352         rgblight_step();
 353       } else {
 354         rgblight_mode(6);
 355       }
 356     }
 357     return false;
 358   case RGB_MODE_SWIRL:
 359     if (record->event.pressed) {
 360       if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
 361         rgblight_step();
 362       } else {
 363         rgblight_mode(9);
 364       }
 365     }
 366     return false;
 367   case RGB_MODE_SNAKE:
 368     if (record->event.pressed) {
 369       if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
 370         rgblight_step();
 371       } else {
 372         rgblight_mode(15);
 373       }
 374     }
 375     return false;
 376   case RGB_MODE_KNIGHT:
 377     if (record->event.pressed) {
 378       if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
 379         rgblight_step();
 380       } else {
 381         rgblight_mode(21);
 382       }
 383     }
 384     return false;
 385   case RGB_MODE_XMAS:
 386     if (record->event.pressed) {
 387       rgblight_mode(24);
 388     }
 389     return false;
 390   case RGB_MODE_GRADIENT:
 391     if (record->event.pressed) {
 392       if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
 393         rgblight_step();
 394       } else {
 395         rgblight_mode(25);
 396       }
 397     }
 398     return false;
 399   #endif
 400     #ifdef PROTOCOL_LUFA
 401     case OUT_AUTO:
 402       if (record->event.pressed) {
 403         set_output(OUTPUT_AUTO);
 404       }
 405       return false;
 406     case OUT_USB:
 407       if (record->event.pressed) {
 408         set_output(OUTPUT_USB);
 409       }
 410       return false;
 411     #ifdef BLUETOOTH_ENABLE
 412     case OUT_BT:
 413       if (record->event.pressed) {
 414         set_output(OUTPUT_BLUETOOTH);
 415       }
 416       return false;
 417     #endif
 418     #endif
 419     case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
 420       if (record->event.pressed) {
 421         // MAGIC actions (BOOTMAGIC without the boot)
 422         if (!eeconfig_is_enabled()) {
 423             eeconfig_init();
 424         }
 425         /* keymap config */
 426         keymap_config.raw = eeconfig_read_keymap();
 427         switch (keycode)
 428         {
 429           case MAGIC_SWAP_CONTROL_CAPSLOCK:
 430             keymap_config.swap_control_capslock = true;
 431             break;
 432           case MAGIC_CAPSLOCK_TO_CONTROL:
 433             keymap_config.capslock_to_control = true;
 434             break;
 435           case MAGIC_SWAP_LALT_LGUI:
 436             keymap_config.swap_lalt_lgui = true;
 437             break;
 438           case MAGIC_SWAP_RALT_RGUI:
 439             keymap_config.swap_ralt_rgui = true;
 440             break;
 441           case MAGIC_NO_GUI:
 442             keymap_config.no_gui = true;
 443             break;
 444           case MAGIC_SWAP_GRAVE_ESC:
 445             keymap_config.swap_grave_esc = true;
 446             break;
 447           case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 448             keymap_config.swap_backslash_backspace = true;
 449             break;
 450           case MAGIC_HOST_NKRO:
 451             keymap_config.nkro = true;
 452             break;
 453           case MAGIC_SWAP_ALT_GUI:
 454             keymap_config.swap_lalt_lgui = true;
 455             keymap_config.swap_ralt_rgui = true;
 456             #ifdef AUDIO_ENABLE
 457               PLAY_SONG(ag_swap_song);
 458             #endif
 459             break;
 460           case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 461             keymap_config.swap_control_capslock = false;
 462             break;
 463           case MAGIC_UNCAPSLOCK_TO_CONTROL:
 464             keymap_config.capslock_to_control = false;
 465             break;
 466           case MAGIC_UNSWAP_LALT_LGUI:
 467             keymap_config.swap_lalt_lgui = false;
 468             break;
 469           case MAGIC_UNSWAP_RALT_RGUI:
 470             keymap_config.swap_ralt_rgui = false;
 471             break;
 472           case MAGIC_UNNO_GUI:
 473             keymap_config.no_gui = false;
 474             break;
 475           case MAGIC_UNSWAP_GRAVE_ESC:
 476             keymap_config.swap_grave_esc = false;
 477             break;
 478           case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 479             keymap_config.swap_backslash_backspace = false;
 480             break;
 481           case MAGIC_UNHOST_NKRO:
 482             keymap_config.nkro = false;
 483             break;
 484           case MAGIC_UNSWAP_ALT_GUI:
 485             keymap_config.swap_lalt_lgui = false;
 486             keymap_config.swap_ralt_rgui = false;
 487             #ifdef AUDIO_ENABLE
 488               PLAY_SONG(ag_norm_song);
 489             #endif
 490             break;
 491           case MAGIC_TOGGLE_NKRO:
 492             keymap_config.nkro = !keymap_config.nkro;
 493             break;
 494           default:
 495             break;
 496         }
 497         eeconfig_update_keymap(keymap_config.raw);
 498         clear_keyboard(); // clear to prevent stuck keys
 499
 500         return false;
 501       }
 502       break;
 503     case KC_LSPO: {
 504       if (record->event.pressed) {
 505         shift_interrupted[0] = false;
 506         scs_timer[0] = timer_read ();
 507         register_mods(MOD_BIT(KC_LSFT));
 508       }
 509       else {
 510         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 511           if (get_mods() & MOD_BIT(KC_RSFT)) {
 512             shift_interrupted[0] = true;
 513             shift_interrupted[1] = true;
 514           }
 515         #endif
 516         if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
 517           register_code(LSPO_KEY);
 518           unregister_code(LSPO_KEY);
 519         }
 520         unregister_mods(MOD_BIT(KC_LSFT));
 521       }
 522       return false;
 523     }
 524
 525     case KC_RSPC: {
 526       if (record->event.pressed) {
 527         shift_interrupted[1] = false;
 528         scs_timer[1] = timer_read ();
 529         register_mods(MOD_BIT(KC_RSFT));
 530       }
 531       else {
 532         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 533           if (get_mods() & MOD_BIT(KC_LSFT)) {
 534             shift_interrupted[0] = true;
 535             shift_interrupted[1] = true;
 536           }
 537         #endif
 538         if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 539           register_code(RSPC_KEY);
 540           unregister_code(RSPC_KEY);
 541         }
 542         unregister_mods(MOD_BIT(KC_RSFT));
 543       }
 544       return false;
 545     }
 546     case GRAVE_ESC: {
 547       uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
 548                                       |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
 549
 550 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 551       // if CTRL is pressed, ESC is always read as ESC, even if SHIFT or GUI is pressed.
 552       // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 553       if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL)))
 554         shifted = 0;
 555 #endif
 556
 557       if (record->event.pressed) {
 558         grave_esc_was_shifted = shifted;
 559         add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 560       }
 561       else {
 562         del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 563       }
 564
 565       send_keyboard_report();
 566     }
 567     default: {
 568       shift_interrupted[0] = true;
 569       shift_interrupted[1] = true;
 570       break;
 571     }
 572   }
 573
 574   return process_action_kb(record);
 575 }
 576
 577 __attribute__ ((weak))
 578 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 579     0, 0, 0, 0, 0, 0, 0, 0,
 580     0, 0, 0, 0, 0, 0, 0, 0,
 581     0, 0, 0, 0, 0, 0, 0, 0,
 582     0, 0, 0, 0, 0, 0, 0, 0,
 583     0, 1, 1, 1, 1, 1, 1, 0,
 584     1, 1, 1, 1, 0, 0, 0, 0,
 585     0, 0, 0, 0, 0, 0, 0, 0,
 586     0, 0, 1, 0, 1, 0, 1, 1,
 587     1, 1, 1, 1, 1, 1, 1, 1,
 588     1, 1, 1, 1, 1, 1, 1, 1,
 589     1, 1, 1, 1, 1, 1, 1, 1,
 590     1, 1, 1, 0, 0, 0, 1, 1,
 591     0, 0, 0, 0, 0, 0, 0, 0,
 592     0, 0, 0, 0, 0, 0, 0, 0,
 593     0, 0, 0, 0, 0, 0, 0, 0,
 594     0, 0, 0, 1, 1, 1, 1, 0
 595 };
 596
 597 __attribute__ ((weak))
 598 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 599     0, 0, 0, 0, 0, 0, 0, 0,
 600     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 601     0, 0, 0, 0, 0, 0, 0, 0,
 602     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 603     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 604     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 605     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 606     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 607     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 608     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 609     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 610     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 611     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 612     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 613     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 614     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 615 };
 616
 617 void send_string(const char *str) {
 618   send_string_with_delay(str, 0);
 619 }
 620
 621 void send_string_P(const char *str) {
 622   send_string_with_delay_P(str, 0);
 623 }
 624
 625 void send_string_with_delay(const char *str, uint8_t interval) {
 626     while (1) {
 627         char ascii_code = *str;
 628         if (!ascii_code) break;
 629         if (ascii_code == 1) {
 630           // tap
 631           uint8_t keycode = *(++str);
 632           register_code(keycode);
 633           unregister_code(keycode);
 634         } else if (ascii_code == 2) {
 635           // down
 636           uint8_t keycode = *(++str);
 637           register_code(keycode);
 638         } else if (ascii_code == 3) {
 639           // up
 640           uint8_t keycode = *(++str);
 641           unregister_code(keycode);
 642         } else {
 643           send_char(ascii_code);
 644         }
 645         ++str;
 646         // interval
 647         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 648     }
 649 }
 650
 651 void send_string_with_delay_P(const char *str, uint8_t interval) {
 652     while (1) {
 653         char ascii_code = pgm_read_byte(str);
 654         if (!ascii_code) break;
 655         if (ascii_code == 1) {
 656           // tap
 657           uint8_t keycode = pgm_read_byte(++str);
 658           register_code(keycode);
 659           unregister_code(keycode);
 660         } else if (ascii_code == 2) {
 661           // down
 662           uint8_t keycode = pgm_read_byte(++str);
 663           register_code(keycode);
 664         } else if (ascii_code == 3) {
 665           // up
 666           uint8_t keycode = pgm_read_byte(++str);
 667           unregister_code(keycode);
 668         } else {
 669           send_char(ascii_code);
 670         }
 671         ++str;
 672         // interval
 673         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 674     }
 675 }
 676
 677 void send_char(char ascii_code) {
 678   uint8_t keycode;
 679   keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 680   if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
 681       register_code(KC_LSFT);
 682       register_code(keycode);
 683       unregister_code(keycode);
 684       unregister_code(KC_LSFT);
 685   } else {
 686       register_code(keycode);
 687       unregister_code(keycode);
 688   }
 689 }
 690
 691 void set_single_persistent_default_layer(uint8_t default_layer) {
 692   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 693     PLAY_SONG(default_layer_songs[default_layer]);
 694   #endif
 695   eeconfig_update_default_layer(1U<<default_layer);
 696   default_layer_set(1U<<default_layer);
 697 }
 698
 699 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 700   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
 701     layer_on(layer3);
 702   } else {
 703     layer_off(layer3);
 704   }
 705 }
 706
 707 void tap_random_base64(void) {
 708   #if defined(__AVR_ATmega32U4__)
 709     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 710   #else
 711     uint8_t key = rand() % 64;
 712   #endif
 713   switch (key) {
 714     case 0 ... 25:
 715       register_code(KC_LSFT);
 716       register_code(key + KC_A);
 717       unregister_code(key + KC_A);
 718       unregister_code(KC_LSFT);
 719       break;
 720     case 26 ... 51:
 721       register_code(key - 26 + KC_A);
 722       unregister_code(key - 26 + KC_A);
 723       break;
 724     case 52:
 725       register_code(KC_0);
 726       unregister_code(KC_0);
 727       break;
 728     case 53 ... 61:
 729       register_code(key - 53 + KC_1);
 730       unregister_code(key - 53 + KC_1);
 731       break;
 732     case 62:
 733       register_code(KC_LSFT);
 734       register_code(KC_EQL);
 735       unregister_code(KC_EQL);
 736       unregister_code(KC_LSFT);
 737       break;
 738     case 63:
 739       register_code(KC_SLSH);
 740       unregister_code(KC_SLSH);
 741       break;
 742   }
 743 }
 744
 745 void matrix_init_quantum() {
 746   #ifdef BACKLIGHT_ENABLE
 747     backlight_init_ports();
 748   #endif
 749   #ifdef AUDIO_ENABLE
 750     audio_init();
 751   #endif
 752   matrix_init_kb();
 753 }
 754
 755 void matrix_scan_quantum() {
 756   #ifdef AUDIO_ENABLE
 757     matrix_scan_music();
 758   #endif
 759
 760   #ifdef TAP_DANCE_ENABLE
 761     matrix_scan_tap_dance();
 762   #endif
 763
 764   #ifdef COMBO_ENABLE
 765     matrix_scan_combo();
 766   #endif
 767
 768   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 769     backlight_task();
 770   #endif
 771
 772   matrix_scan_kb();
 773 }
 774
 775 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 776
 777 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 778
 779 #if BACKLIGHT_PIN == B7
 780 #  define COM1x1 COM1C1
 781 #  define OCR1x  OCR1C
 782 #elif BACKLIGHT_PIN == B6
 783 #  define COM1x1 COM1B1
 784 #  define OCR1x  OCR1B
 785 #elif BACKLIGHT_PIN == B5
 786 #  define COM1x1 COM1A1
 787 #  define OCR1x  OCR1A
 788 #else
 789 #  define NO_BACKLIGHT_CLOCK
 790 #endif
 791
 792 #ifndef BACKLIGHT_ON_STATE
 793 #define BACKLIGHT_ON_STATE 0
 794 #endif
 795
 796 __attribute__ ((weak))
 797 void backlight_init_ports(void)
 798 {
 799
 800   // Setup backlight pin as output and output to on state.
 801   // DDRx |= n
 802   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 803   #if BACKLIGHT_ON_STATE == 0
 804     // PORTx &= ~n
 805     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 806   #else
 807     // PORTx |= n
 808     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 809   #endif
 810
 811   #ifndef NO_BACKLIGHT_CLOCK
 812     // Use full 16-bit resolution.
 813     ICR1 = 0xFFFF;
 814
 815     // I could write a wall of text here to explain... but TL;DW
 816     // Go read the ATmega32u4 datasheet.
 817     // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
 818
 819     // Pin PB7 = OCR1C (Timer 1, Channel C)
 820     // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
 821     // (i.e. start high, go low when counter matches.)
 822     // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
 823     // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
 824
 825     TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
 826     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
 827   #endif
 828
 829   backlight_init();
 830   #ifdef BACKLIGHT_BREATHING
 831     breathing_defaults();
 832   #endif
 833 }
 834
 835 __attribute__ ((weak))
 836 void backlight_set(uint8_t level)
 837 {
 838   // Prevent backlight blink on lowest level
 839   // #if BACKLIGHT_ON_STATE == 0
 840   //   // PORTx &= ~n
 841   //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 842   // #else
 843   //   // PORTx |= n
 844   //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 845   // #endif
 846
 847   if ( level == 0 ) {
 848     #ifndef NO_BACKLIGHT_CLOCK
 849       // Turn off PWM control on backlight pin, revert to output low.
 850       TCCR1A &= ~(_BV(COM1x1));
 851       OCR1x = 0x0;
 852     #else
 853       // #if BACKLIGHT_ON_STATE == 0
 854       //   // PORTx |= n
 855       //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 856       // #else
 857       //   // PORTx &= ~n
 858       //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 859       // #endif
 860     #endif
 861   }
 862   #ifndef NO_BACKLIGHT_CLOCK
 863     else if ( level == BACKLIGHT_LEVELS ) {
 864       // Turn on PWM control of backlight pin
 865       TCCR1A |= _BV(COM1x1);
 866       // Set the brightness
 867       OCR1x = 0xFFFF;
 868     }
 869     else {
 870       // Turn on PWM control of backlight pin
 871       TCCR1A |= _BV(COM1x1);
 872       // Set the brightness
 873       OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
 874     }
 875   #endif
 876
 877   #ifdef BACKLIGHT_BREATHING
 878     breathing_intensity_default();
 879   #endif
 880 }
 881
 882 uint8_t backlight_tick = 0;
 883
 884 void backlight_task(void) {
 885   #ifdef NO_BACKLIGHT_CLOCK
 886   if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 887     #if BACKLIGHT_ON_STATE == 0
 888       // PORTx &= ~n
 889       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 890     #else
 891       // PORTx |= n
 892       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 893     #endif
 894   } else {
 895     #if BACKLIGHT_ON_STATE == 0
 896       // PORTx |= n
 897       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 898     #else
 899       // PORTx &= ~n
 900       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 901     #endif
 902   }
 903   backlight_tick = (backlight_tick + 1) % 16;
 904   #endif
 905 }
 906
 907 #ifdef BACKLIGHT_BREATHING
 908
 909 #define BREATHING_NO_HALT  0
 910 #define BREATHING_HALT_OFF 1
 911 #define BREATHING_HALT_ON  2
 912
 913 static uint8_t breath_intensity;
 914 static uint8_t breath_speed;
 915 static uint16_t breathing_index;
 916 static uint8_t breathing_halt;
 917
 918 void breathing_enable(void)
 919 {
 920     if (get_backlight_level() == 0)
 921     {
 922         breathing_index = 0;
 923     }
 924     else
 925     {
 926         // Set breathing_index to be at the midpoint (brightest point)
 927         breathing_index = 0x20 << breath_speed;
 928     }
 929
 930     breathing_halt = BREATHING_NO_HALT;
 931
 932     // Enable breathing interrupt
 933     TIMSK1 |= _BV(OCIE1A);
 934 }
 935
 936 void breathing_pulse(void)
 937 {
 938     if (get_backlight_level() == 0)
 939     {
 940         breathing_index = 0;
 941     }
 942     else
 943     {
 944         // Set breathing_index to be at the midpoint + 1 (brightest point)
 945         breathing_index = 0x21 << breath_speed;
 946     }
 947
 948     breathing_halt = BREATHING_HALT_ON;
 949
 950     // Enable breathing interrupt
 951     TIMSK1 |= _BV(OCIE1A);
 952 }
 953
 954 void breathing_disable(void)
 955 {
 956     // Disable breathing interrupt
 957     TIMSK1 &= ~_BV(OCIE1A);
 958     backlight_set(get_backlight_level());
 959 }
 960
 961 void breathing_self_disable(void)
 962 {
 963     if (get_backlight_level() == 0)
 964     {
 965         breathing_halt = BREATHING_HALT_OFF;
 966     }
 967     else
 968     {
 969         breathing_halt = BREATHING_HALT_ON;
 970     }
 971
 972     //backlight_set(get_backlight_level());
 973 }
 974
 975 void breathing_toggle(void)
 976 {
 977     if (!is_breathing())
 978     {
 979         if (get_backlight_level() == 0)
 980         {
 981             breathing_index = 0;
 982         }
 983         else
 984         {
 985             // Set breathing_index to be at the midpoint + 1 (brightest point)
 986             breathing_index = 0x21 << breath_speed;
 987         }
 988
 989         breathing_halt = BREATHING_NO_HALT;
 990     }
 991
 992     // Toggle breathing interrupt
 993     TIMSK1 ^= _BV(OCIE1A);
 994
 995     // Restore backlight level
 996     if (!is_breathing())
 997     {
 998         backlight_set(get_backlight_level());
 999     }
1000 }
1001
1002 bool is_breathing(void)
1003 {
1004     return (TIMSK1 && _BV(OCIE1A));
1005 }
1006
1007 void breathing_intensity_default(void)
1008 {
1009     //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
1010     breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
1011 }
1012
1013 void breathing_intensity_set(uint8_t value)
1014 {
1015     breath_intensity = value;
1016 }
1017
1018 void breathing_speed_default(void)
1019 {
1020     breath_speed = 4;
1021 }
1022
1023 void breathing_speed_set(uint8_t value)
1024 {
1025     bool is_breathing_now = is_breathing();
1026     uint8_t old_breath_speed = breath_speed;
1027
1028     if (is_breathing_now)
1029     {
1030         // Disable breathing interrupt
1031         TIMSK1 &= ~_BV(OCIE1A);
1032     }
1033
1034     breath_speed = value;
1035
1036     if (is_breathing_now)
1037     {
1038         // Adjust index to account for new speed
1039         breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
1040
1041         // Enable breathing interrupt
1042         TIMSK1 |= _BV(OCIE1A);
1043     }
1044
1045 }
1046
1047 void breathing_speed_inc(uint8_t value)
1048 {
1049     if ((uint16_t)(breath_speed - value) > 10 )
1050     {
1051         breathing_speed_set(0);
1052     }
1053     else
1054     {
1055         breathing_speed_set(breath_speed - value);
1056     }
1057 }
1058
1059 void breathing_speed_dec(uint8_t value)
1060 {
1061     if ((uint16_t)(breath_speed + value) > 10 )
1062     {
1063         breathing_speed_set(10);
1064     }
1065     else
1066     {
1067         breathing_speed_set(breath_speed + value);
1068     }
1069 }
1070
1071 void breathing_defaults(void)
1072 {
1073     breathing_intensity_default();
1074     breathing_speed_default();
1075     breathing_halt = BREATHING_NO_HALT;
1076 }
1077
1078 /* Breathing Sleep LED brighness(PWM On period) table
1079  * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
1080  *
1081  * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
1082  * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
1083  */
1084 static const uint8_t breathing_table[64] PROGMEM = {
1085   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   2,   4,   6,  10,
1086  15,  23,  32,  44,  58,  74,  93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
1087 255, 252, 245, 233, 218, 199, 179, 157, 135, 113,  93,  74,  58,  44,  32,  23,
1088  15,  10,   6,   4,   2,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
1089 };
1090
1091 ISR(TIMER1_COMPA_vect)
1092 {
1093     // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
1094
1095
1096     uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
1097
1098     if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
1099     {
1100         // Disable breathing interrupt
1101         TIMSK1 &= ~_BV(OCIE1A);
1102     }
1103
1104     OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
1105
1106 }
1107
1108 #endif // breathing
1109
1110 #else // backlight
1111
1112 __attribute__ ((weak))
1113 void backlight_init_ports(void)
1114 {
1115
1116 }
1117
1118 __attribute__ ((weak))
1119 void backlight_set(uint8_t level)
1120 {
1121
1122 }
1123
1124 #endif // backlight
1125
1126
1127 // Functions for spitting out values
1128 //
1129
1130 void send_dword(uint32_t number) { // this might not actually work
1131     uint16_t word = (number >> 16);
1132     send_word(word);
1133     send_word(number & 0xFFFFUL);
1134 }
1135
1136 void send_word(uint16_t number) {
1137     uint8_t byte = number >> 8;
1138     send_byte(byte);
1139     send_byte(number & 0xFF);
1140 }
1141
1142 void send_byte(uint8_t number) {
1143     uint8_t nibble = number >> 4;
1144     send_nibble(nibble);
1145     send_nibble(number & 0xF);
1146 }
1147
1148 void send_nibble(uint8_t number) {
1149     switch (number) {
1150         case 0:
1151             register_code(KC_0);
1152             unregister_code(KC_0);
1153             break;
1154         case 1 ... 9:
1155             register_code(KC_1 + (number - 1));
1156             unregister_code(KC_1 + (number - 1));
1157             break;
1158         case 0xA ... 0xF:
1159             register_code(KC_A + (number - 0xA));
1160             unregister_code(KC_A + (number - 0xA));
1161             break;
1162     }
1163 }
1164
1165
1166 __attribute__((weak))
1167 uint16_t hex_to_keycode(uint8_t hex)
1168 {
1169   hex = hex & 0xF;
1170   if (hex == 0x0) {
1171     return KC_0;
1172   } else if (hex < 0xA) {
1173     return KC_1 + (hex - 0x1);
1174   } else {
1175     return KC_A + (hex - 0xA);
1176   }
1177 }
1178
1179 void api_send_unicode(uint32_t unicode) {
1180 #ifdef API_ENABLE
1181     uint8_t chunk[4];
1182     dword_to_bytes(unicode, chunk);
1183     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1184 #endif
1185 }
1186
1187 __attribute__ ((weak))
1188 void led_set_user(uint8_t usb_led) {
1189
1190 }
1191
1192 __attribute__ ((weak))
1193 void led_set_kb(uint8_t usb_led) {
1194     led_set_user(usb_led);
1195 }
1196
1197 __attribute__ ((weak))
1198 void led_init_ports(void)
1199 {
1200
1201 }
1202
1203 __attribute__ ((weak))
1204 void led_set(uint8_t usb_led)
1205 {
1206
1207   // Example LED Code
1208   //
1209     // // Using PE6 Caps Lock LED
1210     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1211     // {
1212     //     // Output high.
1213     //     DDRE |= (1<<6);
1214     //     PORTE |= (1<<6);
1215     // }
1216     // else
1217     // {
1218     //     // Output low.
1219     //     DDRE &= ~(1<<6);
1220     //     PORTE &= ~(1<<6);
1221     // }
1222
1223   led_set_kb(usb_led);
1224 }
1225
1226
1227 //------------------------------------------------------------------------------
1228 // Override these functions in your keymap file to play different tunes on
1229 // different events such as startup and bootloader jump
1230
1231 __attribute__ ((weak))
1232 void startup_user() {}
1233
1234 __attribute__ ((weak))
1235 void shutdown_user() {}
1236
1237 //------------------------------------------------------------------------------