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 void backlight_task(void) {
 889   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 890     #if BACKLIGHT_ON_STATE == 0
 891       // PORTx &= ~n
 892       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 893     #else
 894       // PORTx |= n
 895       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 896     #endif
 897   } else {
 898     #if BACKLIGHT_ON_STATE == 0
 899       // PORTx |= n
 900       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 901     #else
 902       // PORTx &= ~n
 903       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 904     #endif
 905   }
 906   backlight_tick = backlight_tick + 1 % 16;
 907 }
 908
 909 #ifdef BACKLIGHT_BREATHING
 910 #error "Backlight breathing only available with hardware PWM. Please disable."
 911 #endif
 912
 913 #else // pwm through timer
 914
 915 #define TIMER_TOP 0xFFFFU
 916
 917 // See http://jared.geek.nz/2013/feb/linear-led-pwm
 918 static uint16_t cie_lightness(uint16_t v) {
 919   if (v <= 5243) // if below 8% of max
 920     return v / 9; // same as dividing by 900%
 921   else {
 922     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
 923     // to get a useful result with integer division, we shift left in the expression above
 924     // and revert what we've done again after squaring.
 925     y = y * y * y >> 8;
 926     if (y > 0xFFFFUL) // prevent overflow
 927       return 0xFFFFU;
 928     else
 929       return (uint16_t) y;
 930   }
 931 }
 932
 933 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
 934 static inline void set_pwm(uint16_t val) {
 935   OCR1x = val;
 936 }
 937
 938 __attribute__ ((weak))
 939 void backlight_set(uint8_t level) {
 940   if (level > BACKLIGHT_LEVELS)
 941     level = BACKLIGHT_LEVELS;
 942
 943   if (level == 0) {
 944     // Turn off PWM control on backlight pin
 945     TCCR1A &= ~(_BV(COM1x1));
 946   } else {
 947     // Turn on PWM control of backlight pin
 948     TCCR1A |= _BV(COM1x1);
 949   }
 950   // Set the brightness
 951   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
 952 }
 953
 954 void backlight_task(void) {}
 955
 956 #ifdef BACKLIGHT_BREATHING
 957
 958 #define BREATHING_NO_HALT  0
 959 #define BREATHING_HALT_OFF 1
 960 #define BREATHING_HALT_ON  2
 961 #define BREATHING_STEPS 128
 962
 963 static uint8_t breathing_period = BREATHING_PERIOD;
 964 static uint8_t breathing_halt = BREATHING_NO_HALT;
 965 static uint16_t breathing_counter = 0;
 966
 967 bool is_breathing(void) {
 968     return !!(TIMSK1 & _BV(TOIE1));
 969 }
 970
 971 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
 972 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
 973 #define breathing_min() do {breathing_counter = 0;} while (0)
 974 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
 975
 976 void breathing_enable(void)
 977 {
 978   breathing_counter = 0;
 979   breathing_halt = BREATHING_NO_HALT;
 980   breathing_interrupt_enable();
 981 }
 982
 983 void breathing_pulse(void)
 984 {
 985     if (get_backlight_level() == 0)
 986       breathing_min();
 987     else
 988       breathing_max();
 989     breathing_halt = BREATHING_HALT_ON;
 990     breathing_interrupt_enable();
 991 }
 992
 993 void breathing_disable(void)
 994 {
 995     breathing_interrupt_disable();
 996     // Restore backlight level
 997     backlight_set(get_backlight_level());
 998 }
 999
1000 void breathing_self_disable(void)
1001 {
1002   if (get_backlight_level() == 0)
1003     breathing_halt = BREATHING_HALT_OFF;
1004   else
1005     breathing_halt = BREATHING_HALT_ON;
1006 }
1007
1008 void breathing_toggle(void) {
1009   if (is_breathing())
1010     breathing_disable();
1011   else
1012     breathing_enable();
1013 }
1014
1015 void breathing_period_set(uint8_t value)
1016 {
1017   if (!value)
1018     value = 1;
1019   breathing_period = value;
1020 }
1021
1022 void breathing_period_default(void) {
1023   breathing_period_set(BREATHING_PERIOD);
1024 }
1025
1026 void breathing_period_inc(void)
1027 {
1028   breathing_period_set(breathing_period+1);
1029 }
1030
1031 void breathing_period_dec(void)
1032 {
1033   breathing_period_set(breathing_period-1);
1034 }
1035
1036 /* To generate breathing curve in python:
1037  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1038  */
1039 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};
1040
1041 // Use this before the cie_lightness function.
1042 static inline uint16_t scale_backlight(uint16_t v) {
1043   return v / BACKLIGHT_LEVELS * get_backlight_level();
1044 }
1045
1046 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1047  * about 244 times per second.
1048  */
1049 ISR(TIMER1_OVF_vect)
1050 {
1051   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1052   // resetting after one period to prevent ugly reset at overflow.
1053   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1054   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1055
1056   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1057       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1058   {
1059       breathing_interrupt_disable();
1060   }
1061
1062   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1063 }
1064
1065 #endif // BACKLIGHT_BREATHING
1066
1067 __attribute__ ((weak))
1068 void backlight_init_ports(void)
1069 {
1070   // Setup backlight pin as output and output to on state.
1071   // DDRx |= n
1072   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1073   #if BACKLIGHT_ON_STATE == 0
1074     // PORTx &= ~n
1075     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1076   #else
1077     // PORTx |= n
1078     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1079   #endif
1080   // I could write a wall of text here to explain... but TL;DW
1081   // Go read the ATmega32u4 datasheet.
1082   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1083
1084   // Pin PB7 = OCR1C (Timer 1, Channel C)
1085   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1086   // (i.e. start high, go low when counter matches.)
1087   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1088   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1089
1090   /*
1091   14.8.3:
1092   "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 [..]."
1093   "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)."
1094   */
1095
1096   TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
1097   TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1098   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1099   ICR1 = TIMER_TOP;
1100
1101   backlight_init();
1102   #ifdef BACKLIGHT_BREATHING
1103     breathing_enable();
1104   #endif
1105 }
1106
1107 #endif // NO_HARDWARE_PWM
1108
1109 #else // backlight
1110
1111 __attribute__ ((weak))
1112 void backlight_init_ports(void) {}
1113
1114 __attribute__ ((weak))
1115 void backlight_set(uint8_t level) {}
1116
1117 #endif // backlight
1118
1119
1120 // Functions for spitting out values
1121 //
1122
1123 void send_dword(uint32_t number) { // this might not actually work
1124     uint16_t word = (number >> 16);
1125     send_word(word);
1126     send_word(number & 0xFFFFUL);
1127 }
1128
1129 void send_word(uint16_t number) {
1130     uint8_t byte = number >> 8;
1131     send_byte(byte);
1132     send_byte(number & 0xFF);
1133 }
1134
1135 void send_byte(uint8_t number) {
1136     uint8_t nibble = number >> 4;
1137     send_nibble(nibble);
1138     send_nibble(number & 0xF);
1139 }
1140
1141 void send_nibble(uint8_t number) {
1142     switch (number) {
1143         case 0:
1144             register_code(KC_0);
1145             unregister_code(KC_0);
1146             break;
1147         case 1 ... 9:
1148             register_code(KC_1 + (number - 1));
1149             unregister_code(KC_1 + (number - 1));
1150             break;
1151         case 0xA ... 0xF:
1152             register_code(KC_A + (number - 0xA));
1153             unregister_code(KC_A + (number - 0xA));
1154             break;
1155     }
1156 }
1157
1158
1159 __attribute__((weak))
1160 uint16_t hex_to_keycode(uint8_t hex)
1161 {
1162   hex = hex & 0xF;
1163   if (hex == 0x0) {
1164     return KC_0;
1165   } else if (hex < 0xA) {
1166     return KC_1 + (hex - 0x1);
1167   } else {
1168     return KC_A + (hex - 0xA);
1169   }
1170 }
1171
1172 void api_send_unicode(uint32_t unicode) {
1173 #ifdef API_ENABLE
1174     uint8_t chunk[4];
1175     dword_to_bytes(unicode, chunk);
1176     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1177 #endif
1178 }
1179
1180 __attribute__ ((weak))
1181 void led_set_user(uint8_t usb_led) {
1182
1183 }
1184
1185 __attribute__ ((weak))
1186 void led_set_kb(uint8_t usb_led) {
1187     led_set_user(usb_led);
1188 }
1189
1190 __attribute__ ((weak))
1191 void led_init_ports(void)
1192 {
1193
1194 }
1195
1196 __attribute__ ((weak))
1197 void led_set(uint8_t usb_led)
1198 {
1199
1200   // Example LED Code
1201   //
1202     // // Using PE6 Caps Lock LED
1203     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1204     // {
1205     //     // Output high.
1206     //     DDRE |= (1<<6);
1207     //     PORTE |= (1<<6);
1208     // }
1209     // else
1210     // {
1211     //     // Output low.
1212     //     DDRE &= ~(1<<6);
1213     //     PORTE &= ~(1<<6);
1214     // }
1215
1216   led_set_kb(usb_led);
1217 }
1218
1219
1220 //------------------------------------------------------------------------------
1221 // Override these functions in your keymap file to play different tunes on
1222 // different events such as startup and bootloader jump
1223
1224 __attribute__ ((weak))
1225 void startup_user() {}
1226
1227 __attribute__ ((weak))
1228 void shutdown_user() {}
1229
1230 //------------------------------------------------------------------------------