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_ALT_OVERRIDE
 552       // if ALT is pressed, ESC is always sent
 553       // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 554       if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 555         shifted = 0;
 556       }
 557 #endif
 558
 559 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 560       // if CTRL is pressed, ESC is always sent
 561       // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 562       if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 563         shifted = 0;
 564       }
 565 #endif
 566
 567 #ifdef GRAVE_ESC_GUI_OVERRIDE
 568       // if GUI is pressed, ESC is always sent
 569       if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 570         shifted = 0;
 571       }
 572 #endif
 573
 574 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 575       // if SHIFT is pressed, ESC is always sent
 576       if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 577         shifted = 0;
 578       }
 579 #endif
 580
 581       if (record->event.pressed) {
 582         grave_esc_was_shifted = shifted;
 583         add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 584       }
 585       else {
 586         del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 587       }
 588
 589       send_keyboard_report();
 590     }
 591     default: {
 592       shift_interrupted[0] = true;
 593       shift_interrupted[1] = true;
 594       break;
 595     }
 596   }
 597
 598   return process_action_kb(record);
 599 }
 600
 601 __attribute__ ((weak))
 602 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 603     0, 0, 0, 0, 0, 0, 0, 0,
 604     0, 0, 0, 0, 0, 0, 0, 0,
 605     0, 0, 0, 0, 0, 0, 0, 0,
 606     0, 0, 0, 0, 0, 0, 0, 0,
 607     0, 1, 1, 1, 1, 1, 1, 0,
 608     1, 1, 1, 1, 0, 0, 0, 0,
 609     0, 0, 0, 0, 0, 0, 0, 0,
 610     0, 0, 1, 0, 1, 0, 1, 1,
 611     1, 1, 1, 1, 1, 1, 1, 1,
 612     1, 1, 1, 1, 1, 1, 1, 1,
 613     1, 1, 1, 1, 1, 1, 1, 1,
 614     1, 1, 1, 0, 0, 0, 1, 1,
 615     0, 0, 0, 0, 0, 0, 0, 0,
 616     0, 0, 0, 0, 0, 0, 0, 0,
 617     0, 0, 0, 0, 0, 0, 0, 0,
 618     0, 0, 0, 1, 1, 1, 1, 0
 619 };
 620
 621 __attribute__ ((weak))
 622 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 623     0, 0, 0, 0, 0, 0, 0, 0,
 624     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 625     0, 0, 0, 0, 0, 0, 0, 0,
 626     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 627     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 628     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 629     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 630     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 631     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 632     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 633     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 634     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 635     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 636     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 637     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 638     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 639 };
 640
 641 void send_string(const char *str) {
 642   send_string_with_delay(str, 0);
 643 }
 644
 645 void send_string_P(const char *str) {
 646   send_string_with_delay_P(str, 0);
 647 }
 648
 649 void send_string_with_delay(const char *str, uint8_t interval) {
 650     while (1) {
 651         char ascii_code = *str;
 652         if (!ascii_code) break;
 653         if (ascii_code == 1) {
 654           // tap
 655           uint8_t keycode = *(++str);
 656           register_code(keycode);
 657           unregister_code(keycode);
 658         } else if (ascii_code == 2) {
 659           // down
 660           uint8_t keycode = *(++str);
 661           register_code(keycode);
 662         } else if (ascii_code == 3) {
 663           // up
 664           uint8_t keycode = *(++str);
 665           unregister_code(keycode);
 666         } else {
 667           send_char(ascii_code);
 668         }
 669         ++str;
 670         // interval
 671         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 672     }
 673 }
 674
 675 void send_string_with_delay_P(const char *str, uint8_t interval) {
 676     while (1) {
 677         char ascii_code = pgm_read_byte(str);
 678         if (!ascii_code) break;
 679         if (ascii_code == 1) {
 680           // tap
 681           uint8_t keycode = pgm_read_byte(++str);
 682           register_code(keycode);
 683           unregister_code(keycode);
 684         } else if (ascii_code == 2) {
 685           // down
 686           uint8_t keycode = pgm_read_byte(++str);
 687           register_code(keycode);
 688         } else if (ascii_code == 3) {
 689           // up
 690           uint8_t keycode = pgm_read_byte(++str);
 691           unregister_code(keycode);
 692         } else {
 693           send_char(ascii_code);
 694         }
 695         ++str;
 696         // interval
 697         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 698     }
 699 }
 700
 701 void send_char(char ascii_code) {
 702   uint8_t keycode;
 703   keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 704   if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
 705       register_code(KC_LSFT);
 706       register_code(keycode);
 707       unregister_code(keycode);
 708       unregister_code(KC_LSFT);
 709   } else {
 710       register_code(keycode);
 711       unregister_code(keycode);
 712   }
 713 }
 714
 715 void set_single_persistent_default_layer(uint8_t default_layer) {
 716   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 717     PLAY_SONG(default_layer_songs[default_layer]);
 718   #endif
 719   eeconfig_update_default_layer(1U<<default_layer);
 720   default_layer_set(1U<<default_layer);
 721 }
 722
 723 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 724   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
 725     layer_on(layer3);
 726   } else {
 727     layer_off(layer3);
 728   }
 729 }
 730
 731 void tap_random_base64(void) {
 732   #if defined(__AVR_ATmega32U4__)
 733     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 734   #else
 735     uint8_t key = rand() % 64;
 736   #endif
 737   switch (key) {
 738     case 0 ... 25:
 739       register_code(KC_LSFT);
 740       register_code(key + KC_A);
 741       unregister_code(key + KC_A);
 742       unregister_code(KC_LSFT);
 743       break;
 744     case 26 ... 51:
 745       register_code(key - 26 + KC_A);
 746       unregister_code(key - 26 + KC_A);
 747       break;
 748     case 52:
 749       register_code(KC_0);
 750       unregister_code(KC_0);
 751       break;
 752     case 53 ... 61:
 753       register_code(key - 53 + KC_1);
 754       unregister_code(key - 53 + KC_1);
 755       break;
 756     case 62:
 757       register_code(KC_LSFT);
 758       register_code(KC_EQL);
 759       unregister_code(KC_EQL);
 760       unregister_code(KC_LSFT);
 761       break;
 762     case 63:
 763       register_code(KC_SLSH);
 764       unregister_code(KC_SLSH);
 765       break;
 766   }
 767 }
 768
 769 void matrix_init_quantum() {
 770   #ifdef BACKLIGHT_ENABLE
 771     backlight_init_ports();
 772   #endif
 773   #ifdef AUDIO_ENABLE
 774     audio_init();
 775   #endif
 776   matrix_init_kb();
 777 }
 778
 779 void matrix_scan_quantum() {
 780   #ifdef AUDIO_ENABLE
 781     matrix_scan_music();
 782   #endif
 783
 784   #ifdef TAP_DANCE_ENABLE
 785     matrix_scan_tap_dance();
 786   #endif
 787
 788   #ifdef COMBO_ENABLE
 789     matrix_scan_combo();
 790   #endif
 791
 792   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 793     backlight_task();
 794   #endif
 795
 796   matrix_scan_kb();
 797 }
 798
 799 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 800
 801 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 802
 803 #if BACKLIGHT_PIN == B7
 804 #  define COM1x1 COM1C1
 805 #  define OCR1x  OCR1C
 806 #elif BACKLIGHT_PIN == B6
 807 #  define COM1x1 COM1B1
 808 #  define OCR1x  OCR1B
 809 #elif BACKLIGHT_PIN == B5
 810 #  define COM1x1 COM1A1
 811 #  define OCR1x  OCR1A
 812 #else
 813 #  define NO_BACKLIGHT_CLOCK
 814 #endif
 815
 816 #ifndef BACKLIGHT_ON_STATE
 817 #define BACKLIGHT_ON_STATE 0
 818 #endif
 819
 820 __attribute__ ((weak))
 821 void backlight_init_ports(void)
 822 {
 823
 824   // Setup backlight pin as output and output to on state.
 825   // DDRx |= n
 826   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 827   #if BACKLIGHT_ON_STATE == 0
 828     // PORTx &= ~n
 829     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 830   #else
 831     // PORTx |= n
 832     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 833   #endif
 834
 835   #ifndef NO_BACKLIGHT_CLOCK
 836     // Use full 16-bit resolution.
 837     ICR1 = 0xFFFF;
 838
 839     // I could write a wall of text here to explain... but TL;DW
 840     // Go read the ATmega32u4 datasheet.
 841     // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
 842
 843     // Pin PB7 = OCR1C (Timer 1, Channel C)
 844     // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
 845     // (i.e. start high, go low when counter matches.)
 846     // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
 847     // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
 848
 849     TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
 850     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
 851   #endif
 852
 853   backlight_init();
 854   #ifdef BACKLIGHT_BREATHING
 855     breathing_defaults();
 856   #endif
 857 }
 858
 859 __attribute__ ((weak))
 860 void backlight_set(uint8_t level)
 861 {
 862   // Prevent backlight blink on lowest level
 863   // #if BACKLIGHT_ON_STATE == 0
 864   //   // PORTx &= ~n
 865   //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 866   // #else
 867   //   // PORTx |= n
 868   //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 869   // #endif
 870
 871   if ( level == 0 ) {
 872     #ifndef NO_BACKLIGHT_CLOCK
 873       // Turn off PWM control on backlight pin, revert to output low.
 874       TCCR1A &= ~(_BV(COM1x1));
 875       OCR1x = 0x0;
 876     #else
 877       // #if BACKLIGHT_ON_STATE == 0
 878       //   // PORTx |= n
 879       //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 880       // #else
 881       //   // PORTx &= ~n
 882       //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 883       // #endif
 884     #endif
 885   }
 886   #ifndef NO_BACKLIGHT_CLOCK
 887     else if ( level == BACKLIGHT_LEVELS ) {
 888       // Turn on PWM control of backlight pin
 889       TCCR1A |= _BV(COM1x1);
 890       // Set the brightness
 891       OCR1x = 0xFFFF;
 892     }
 893     else {
 894       // Turn on PWM control of backlight pin
 895       TCCR1A |= _BV(COM1x1);
 896       // Set the brightness
 897       OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
 898     }
 899   #endif
 900
 901   #ifdef BACKLIGHT_BREATHING
 902     breathing_intensity_default();
 903   #endif
 904 }
 905
 906 uint8_t backlight_tick = 0;
 907
 908 void backlight_task(void) {
 909   #ifdef NO_BACKLIGHT_CLOCK
 910   if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 911     #if BACKLIGHT_ON_STATE == 0
 912       // PORTx &= ~n
 913       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 914     #else
 915       // PORTx |= n
 916       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 917     #endif
 918   } else {
 919     #if BACKLIGHT_ON_STATE == 0
 920       // PORTx |= n
 921       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 922     #else
 923       // PORTx &= ~n
 924       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 925     #endif
 926   }
 927   backlight_tick = (backlight_tick + 1) % 16;
 928   #endif
 929 }
 930
 931 #ifdef BACKLIGHT_BREATHING
 932
 933 #define BREATHING_NO_HALT  0
 934 #define BREATHING_HALT_OFF 1
 935 #define BREATHING_HALT_ON  2
 936
 937 static uint8_t breath_intensity;
 938 static uint8_t breath_speed;
 939 static uint16_t breathing_index;
 940 static uint8_t breathing_halt;
 941
 942 void breathing_enable(void)
 943 {
 944     if (get_backlight_level() == 0)
 945     {
 946         breathing_index = 0;
 947     }
 948     else
 949     {
 950         // Set breathing_index to be at the midpoint (brightest point)
 951         breathing_index = 0x20 << breath_speed;
 952     }
 953
 954     breathing_halt = BREATHING_NO_HALT;
 955
 956     // Enable breathing interrupt
 957     TIMSK1 |= _BV(OCIE1A);
 958 }
 959
 960 void breathing_pulse(void)
 961 {
 962     if (get_backlight_level() == 0)
 963     {
 964         breathing_index = 0;
 965     }
 966     else
 967     {
 968         // Set breathing_index to be at the midpoint + 1 (brightest point)
 969         breathing_index = 0x21 << breath_speed;
 970     }
 971
 972     breathing_halt = BREATHING_HALT_ON;
 973
 974     // Enable breathing interrupt
 975     TIMSK1 |= _BV(OCIE1A);
 976 }
 977
 978 void breathing_disable(void)
 979 {
 980     // Disable breathing interrupt
 981     TIMSK1 &= ~_BV(OCIE1A);
 982     backlight_set(get_backlight_level());
 983 }
 984
 985 void breathing_self_disable(void)
 986 {
 987     if (get_backlight_level() == 0)
 988     {
 989         breathing_halt = BREATHING_HALT_OFF;
 990     }
 991     else
 992     {
 993         breathing_halt = BREATHING_HALT_ON;
 994     }
 995
 996     //backlight_set(get_backlight_level());
 997 }
 998
 999 void breathing_toggle(void)
1000 {
1001     if (!is_breathing())
1002     {
1003         if (get_backlight_level() == 0)
1004         {
1005             breathing_index = 0;
1006         }
1007         else
1008         {
1009             // Set breathing_index to be at the midpoint + 1 (brightest point)
1010             breathing_index = 0x21 << breath_speed;
1011         }
1012
1013         breathing_halt = BREATHING_NO_HALT;
1014     }
1015
1016     // Toggle breathing interrupt
1017     TIMSK1 ^= _BV(OCIE1A);
1018
1019     // Restore backlight level
1020     if (!is_breathing())
1021     {
1022         backlight_set(get_backlight_level());
1023     }
1024 }
1025
1026 bool is_breathing(void)
1027 {
1028     return (TIMSK1 && _BV(OCIE1A));
1029 }
1030
1031 void breathing_intensity_default(void)
1032 {
1033     //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
1034     breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
1035 }
1036
1037 void breathing_intensity_set(uint8_t value)
1038 {
1039     breath_intensity = value;
1040 }
1041
1042 void breathing_speed_default(void)
1043 {
1044     breath_speed = 4;
1045 }
1046
1047 void breathing_speed_set(uint8_t value)
1048 {
1049     bool is_breathing_now = is_breathing();
1050     uint8_t old_breath_speed = breath_speed;
1051
1052     if (is_breathing_now)
1053     {
1054         // Disable breathing interrupt
1055         TIMSK1 &= ~_BV(OCIE1A);
1056     }
1057
1058     breath_speed = value;
1059
1060     if (is_breathing_now)
1061     {
1062         // Adjust index to account for new speed
1063         breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
1064
1065         // Enable breathing interrupt
1066         TIMSK1 |= _BV(OCIE1A);
1067     }
1068
1069 }
1070
1071 void breathing_speed_inc(uint8_t value)
1072 {
1073     if ((uint16_t)(breath_speed - value) > 10 )
1074     {
1075         breathing_speed_set(0);
1076     }
1077     else
1078     {
1079         breathing_speed_set(breath_speed - value);
1080     }
1081 }
1082
1083 void breathing_speed_dec(uint8_t value)
1084 {
1085     if ((uint16_t)(breath_speed + value) > 10 )
1086     {
1087         breathing_speed_set(10);
1088     }
1089     else
1090     {
1091         breathing_speed_set(breath_speed + value);
1092     }
1093 }
1094
1095 void breathing_defaults(void)
1096 {
1097     breathing_intensity_default();
1098     breathing_speed_default();
1099     breathing_halt = BREATHING_NO_HALT;
1100 }
1101
1102 /* Breathing Sleep LED brighness(PWM On period) table
1103  * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
1104  *
1105  * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
1106  * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
1107  */
1108 static const uint8_t breathing_table[64] PROGMEM = {
1109   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   2,   4,   6,  10,
1110  15,  23,  32,  44,  58,  74,  93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
1111 255, 252, 245, 233, 218, 199, 179, 157, 135, 113,  93,  74,  58,  44,  32,  23,
1112  15,  10,   6,   4,   2,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
1113 };
1114
1115 ISR(TIMER1_COMPA_vect)
1116 {
1117     // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
1118
1119
1120     uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
1121
1122     if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
1123     {
1124         // Disable breathing interrupt
1125         TIMSK1 &= ~_BV(OCIE1A);
1126     }
1127
1128     OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
1129
1130 }
1131
1132 #endif // breathing
1133
1134 #else // backlight
1135
1136 __attribute__ ((weak))
1137 void backlight_init_ports(void)
1138 {
1139
1140 }
1141
1142 __attribute__ ((weak))
1143 void backlight_set(uint8_t level)
1144 {
1145
1146 }
1147
1148 #endif // backlight
1149
1150
1151 // Functions for spitting out values
1152 //
1153
1154 void send_dword(uint32_t number) { // this might not actually work
1155     uint16_t word = (number >> 16);
1156     send_word(word);
1157     send_word(number & 0xFFFFUL);
1158 }
1159
1160 void send_word(uint16_t number) {
1161     uint8_t byte = number >> 8;
1162     send_byte(byte);
1163     send_byte(number & 0xFF);
1164 }
1165
1166 void send_byte(uint8_t number) {
1167     uint8_t nibble = number >> 4;
1168     send_nibble(nibble);
1169     send_nibble(number & 0xF);
1170 }
1171
1172 void send_nibble(uint8_t number) {
1173     switch (number) {
1174         case 0:
1175             register_code(KC_0);
1176             unregister_code(KC_0);
1177             break;
1178         case 1 ... 9:
1179             register_code(KC_1 + (number - 1));
1180             unregister_code(KC_1 + (number - 1));
1181             break;
1182         case 0xA ... 0xF:
1183             register_code(KC_A + (number - 0xA));
1184             unregister_code(KC_A + (number - 0xA));
1185             break;
1186     }
1187 }
1188
1189
1190 __attribute__((weak))
1191 uint16_t hex_to_keycode(uint8_t hex)
1192 {
1193   hex = hex & 0xF;
1194   if (hex == 0x0) {
1195     return KC_0;
1196   } else if (hex < 0xA) {
1197     return KC_1 + (hex - 0x1);
1198   } else {
1199     return KC_A + (hex - 0xA);
1200   }
1201 }
1202
1203 void api_send_unicode(uint32_t unicode) {
1204 #ifdef API_ENABLE
1205     uint8_t chunk[4];
1206     dword_to_bytes(unicode, chunk);
1207     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1208 #endif
1209 }
1210
1211 __attribute__ ((weak))
1212 void led_set_user(uint8_t usb_led) {
1213
1214 }
1215
1216 __attribute__ ((weak))
1217 void led_set_kb(uint8_t usb_led) {
1218     led_set_user(usb_led);
1219 }
1220
1221 __attribute__ ((weak))
1222 void led_init_ports(void)
1223 {
1224
1225 }
1226
1227 __attribute__ ((weak))
1228 void led_set(uint8_t usb_led)
1229 {
1230
1231   // Example LED Code
1232   //
1233     // // Using PE6 Caps Lock LED
1234     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1235     // {
1236     //     // Output high.
1237     //     DDRE |= (1<<6);
1238     //     PORTE |= (1<<6);
1239     // }
1240     // else
1241     // {
1242     //     // Output low.
1243     //     DDRE &= ~(1<<6);
1244     //     PORTE &= ~(1<<6);
1245     // }
1246
1247   led_set_kb(usb_led);
1248 }
1249
1250
1251 //------------------------------------------------------------------------------
1252 // Override these functions in your keymap file to play different tunes on
1253 // different events such as startup and bootloader jump
1254
1255 __attribute__ ((weak))
1256 void startup_user() {}
1257
1258 __attribute__ ((weak))
1259 void shutdown_user() {}
1260
1261 //------------------------------------------------------------------------------