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