quantum/quantum.c

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