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