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 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 784   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
 785     layer_on(layer3);
 786   } else {
 787     layer_off(layer3);
 788   }
 789 }
 790
 791 void tap_random_base64(void) {
 792   #if defined(__AVR_ATmega32U4__)
 793     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 794   #else
 795     uint8_t key = rand() % 64;
 796   #endif
 797   switch (key) {
 798     case 0 ... 25:
 799       register_code(KC_LSFT);
 800       register_code(key + KC_A);
 801       unregister_code(key + KC_A);
 802       unregister_code(KC_LSFT);
 803       break;
 804     case 26 ... 51:
 805       register_code(key - 26 + KC_A);
 806       unregister_code(key - 26 + KC_A);
 807       break;
 808     case 52:
 809       register_code(KC_0);
 810       unregister_code(KC_0);
 811       break;
 812     case 53 ... 61:
 813       register_code(key - 53 + KC_1);
 814       unregister_code(key - 53 + KC_1);
 815       break;
 816     case 62:
 817       register_code(KC_LSFT);
 818       register_code(KC_EQL);
 819       unregister_code(KC_EQL);
 820       unregister_code(KC_LSFT);
 821       break;
 822     case 63:
 823       register_code(KC_SLSH);
 824       unregister_code(KC_SLSH);
 825       break;
 826   }
 827 }
 828
 829 void matrix_init_quantum() {
 830   #ifdef BACKLIGHT_ENABLE
 831     backlight_init_ports();
 832   #endif
 833   #ifdef AUDIO_ENABLE
 834     audio_init();
 835   #endif
 836   matrix_init_kb();
 837 }
 838
 839 void matrix_scan_quantum() {
 840   #if defined(AUDIO_ENABLE)
 841     matrix_scan_music();
 842   #endif
 843
 844   #ifdef TAP_DANCE_ENABLE
 845     matrix_scan_tap_dance();
 846   #endif
 847
 848   #ifdef COMBO_ENABLE
 849     matrix_scan_combo();
 850   #endif
 851
 852   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 853     backlight_task();
 854   #endif
 855
 856   matrix_scan_kb();
 857 }
 858
 859 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 860
 861 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 862
 863 // depending on the pin, we use a different output compare unit
 864 #if BACKLIGHT_PIN == B7
 865 #  define COM1x1 COM1C1
 866 #  define OCR1x  OCR1C
 867 #elif BACKLIGHT_PIN == B6
 868 #  define COM1x1 COM1B1
 869 #  define OCR1x  OCR1B
 870 #elif BACKLIGHT_PIN == B5
 871 #  define COM1x1 COM1A1
 872 #  define OCR1x  OCR1A
 873 #else
 874 #  define NO_HARDWARE_PWM
 875 #endif
 876
 877 #ifndef BACKLIGHT_ON_STATE
 878 #define BACKLIGHT_ON_STATE 0
 879 #endif
 880
 881 #ifdef NO_HARDWARE_PWM // pwm through software
 882
 883 __attribute__ ((weak))
 884 void backlight_init_ports(void)
 885 {
 886   // Setup backlight pin as output and output to on state.
 887   // DDRx |= n
 888   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 889   #if BACKLIGHT_ON_STATE == 0
 890     // PORTx &= ~n
 891     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 892   #else
 893     // PORTx |= n
 894     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 895   #endif
 896 }
 897
 898 __attribute__ ((weak))
 899 void backlight_set(uint8_t level) {}
 900
 901 uint8_t backlight_tick = 0;
 902
 903 #ifndef BACKLIGHT_CUSTOM_DRIVER
 904 void backlight_task(void) {
 905   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 906     #if BACKLIGHT_ON_STATE == 0
 907       // PORTx &= ~n
 908       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 909     #else
 910       // PORTx |= n
 911       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 912     #endif
 913   } else {
 914     #if BACKLIGHT_ON_STATE == 0
 915       // PORTx |= n
 916       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 917     #else
 918       // PORTx &= ~n
 919       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 920     #endif
 921   }
 922   backlight_tick = (backlight_tick + 1) % 16;
 923 }
 924 #endif
 925
 926 #ifdef BACKLIGHT_BREATHING
 927   #ifndef BACKLIGHT_CUSTOM_DRIVER
 928   #error "Backlight breathing only available with hardware PWM. Please disable."
 929   #endif
 930 #endif
 931
 932 #else // pwm through timer
 933
 934 #define TIMER_TOP 0xFFFFU
 935
 936 // See http://jared.geek.nz/2013/feb/linear-led-pwm
 937 static uint16_t cie_lightness(uint16_t v) {
 938   if (v <= 5243) // if below 8% of max
 939     return v / 9; // same as dividing by 900%
 940   else {
 941     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
 942     // to get a useful result with integer division, we shift left in the expression above
 943     // and revert what we've done again after squaring.
 944     y = y * y * y >> 8;
 945     if (y > 0xFFFFUL) // prevent overflow
 946       return 0xFFFFU;
 947     else
 948       return (uint16_t) y;
 949   }
 950 }
 951
 952 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
 953 static inline void set_pwm(uint16_t val) {
 954   OCR1x = val;
 955 }
 956
 957 #ifndef BACKLIGHT_CUSTOM_DRIVER
 958 __attribute__ ((weak))
 959 void backlight_set(uint8_t level) {
 960   if (level > BACKLIGHT_LEVELS)
 961     level = BACKLIGHT_LEVELS;
 962
 963   if (level == 0) {
 964     // Turn off PWM control on backlight pin
 965     TCCR1A &= ~(_BV(COM1x1));
 966   } else {
 967     // Turn on PWM control of backlight pin
 968     TCCR1A |= _BV(COM1x1);
 969   }
 970   // Set the brightness
 971   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
 972 }
 973
 974 void backlight_task(void) {}
 975 #endif  // BACKLIGHT_CUSTOM_DRIVER
 976
 977 #ifdef BACKLIGHT_BREATHING
 978
 979 #define BREATHING_NO_HALT  0
 980 #define BREATHING_HALT_OFF 1
 981 #define BREATHING_HALT_ON  2
 982 #define BREATHING_STEPS 128
 983
 984 static uint8_t breathing_period = BREATHING_PERIOD;
 985 static uint8_t breathing_halt = BREATHING_NO_HALT;
 986 static uint16_t breathing_counter = 0;
 987
 988 bool is_breathing(void) {
 989     return !!(TIMSK1 & _BV(TOIE1));
 990 }
 991
 992 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
 993 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
 994 #define breathing_min() do {breathing_counter = 0;} while (0)
 995 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
 996
 997 void breathing_enable(void)
 998 {
 999   breathing_counter = 0;
1000   breathing_halt = BREATHING_NO_HALT;
1001   breathing_interrupt_enable();
1002 }
1003
1004 void breathing_pulse(void)
1005 {
1006     if (get_backlight_level() == 0)
1007       breathing_min();
1008     else
1009       breathing_max();
1010     breathing_halt = BREATHING_HALT_ON;
1011     breathing_interrupt_enable();
1012 }
1013
1014 void breathing_disable(void)
1015 {
1016     breathing_interrupt_disable();
1017     // Restore backlight level
1018     backlight_set(get_backlight_level());
1019 }
1020
1021 void breathing_self_disable(void)
1022 {
1023   if (get_backlight_level() == 0)
1024     breathing_halt = BREATHING_HALT_OFF;
1025   else
1026     breathing_halt = BREATHING_HALT_ON;
1027 }
1028
1029 void breathing_toggle(void) {
1030   if (is_breathing())
1031     breathing_disable();
1032   else
1033     breathing_enable();
1034 }
1035
1036 void breathing_period_set(uint8_t value)
1037 {
1038   if (!value)
1039     value = 1;
1040   breathing_period = value;
1041 }
1042
1043 void breathing_period_default(void) {
1044   breathing_period_set(BREATHING_PERIOD);
1045 }
1046
1047 void breathing_period_inc(void)
1048 {
1049   breathing_period_set(breathing_period+1);
1050 }
1051
1052 void breathing_period_dec(void)
1053 {
1054   breathing_period_set(breathing_period-1);
1055 }
1056
1057 /* To generate breathing curve in python:
1058  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1059  */
1060 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};
1061
1062 // Use this before the cie_lightness function.
1063 static inline uint16_t scale_backlight(uint16_t v) {
1064   return v / BACKLIGHT_LEVELS * get_backlight_level();
1065 }
1066
1067 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1068  * about 244 times per second.
1069  */
1070 ISR(TIMER1_OVF_vect)
1071 {
1072   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1073   // resetting after one period to prevent ugly reset at overflow.
1074   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1075   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1076
1077   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1078       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1079   {
1080       breathing_interrupt_disable();
1081   }
1082
1083   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1084 }
1085
1086 #endif // BACKLIGHT_BREATHING
1087
1088 __attribute__ ((weak))
1089 void backlight_init_ports(void)
1090 {
1091   // Setup backlight pin as output and output to on state.
1092   // DDRx |= n
1093   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1094   #if BACKLIGHT_ON_STATE == 0
1095     // PORTx &= ~n
1096     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1097   #else
1098     // PORTx |= n
1099     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1100   #endif
1101   // I could write a wall of text here to explain... but TL;DW
1102   // Go read the ATmega32u4 datasheet.
1103   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1104
1105   // Pin PB7 = OCR1C (Timer 1, Channel C)
1106   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1107   // (i.e. start high, go low when counter matches.)
1108   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1109   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1110
1111   /*
1112   14.8.3:
1113   "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 [..]."
1114   "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)."
1115   */
1116
1117   TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
1118   TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1119   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1120   ICR1 = TIMER_TOP;
1121
1122   backlight_init();
1123   #ifdef BACKLIGHT_BREATHING
1124     breathing_enable();
1125   #endif
1126 }
1127
1128 #endif // NO_HARDWARE_PWM
1129
1130 #else // backlight
1131
1132 __attribute__ ((weak))
1133 void backlight_init_ports(void) {}
1134
1135 __attribute__ ((weak))
1136 void backlight_set(uint8_t level) {}
1137
1138 #endif // backlight
1139
1140
1141 // Functions for spitting out values
1142 //
1143
1144 void send_dword(uint32_t number) { // this might not actually work
1145     uint16_t word = (number >> 16);
1146     send_word(word);
1147     send_word(number & 0xFFFFUL);
1148 }
1149
1150 void send_word(uint16_t number) {
1151     uint8_t byte = number >> 8;
1152     send_byte(byte);
1153     send_byte(number & 0xFF);
1154 }
1155
1156 void send_byte(uint8_t number) {
1157     uint8_t nibble = number >> 4;
1158     send_nibble(nibble);
1159     send_nibble(number & 0xF);
1160 }
1161
1162 void send_nibble(uint8_t number) {
1163     switch (number) {
1164         case 0:
1165             register_code(KC_0);
1166             unregister_code(KC_0);
1167             break;
1168         case 1 ... 9:
1169             register_code(KC_1 + (number - 1));
1170             unregister_code(KC_1 + (number - 1));
1171             break;
1172         case 0xA ... 0xF:
1173             register_code(KC_A + (number - 0xA));
1174             unregister_code(KC_A + (number - 0xA));
1175             break;
1176     }
1177 }
1178
1179
1180 __attribute__((weak))
1181 uint16_t hex_to_keycode(uint8_t hex)
1182 {
1183   hex = hex & 0xF;
1184   if (hex == 0x0) {
1185     return KC_0;
1186   } else if (hex < 0xA) {
1187     return KC_1 + (hex - 0x1);
1188   } else {
1189     return KC_A + (hex - 0xA);
1190   }
1191 }
1192
1193 void api_send_unicode(uint32_t unicode) {
1194 #ifdef API_ENABLE
1195     uint8_t chunk[4];
1196     dword_to_bytes(unicode, chunk);
1197     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1198 #endif
1199 }
1200
1201 __attribute__ ((weak))
1202 void led_set_user(uint8_t usb_led) {
1203
1204 }
1205
1206 __attribute__ ((weak))
1207 void led_set_kb(uint8_t usb_led) {
1208     led_set_user(usb_led);
1209 }
1210
1211 __attribute__ ((weak))
1212 void led_init_ports(void)
1213 {
1214
1215 }
1216
1217 __attribute__ ((weak))
1218 void led_set(uint8_t usb_led)
1219 {
1220
1221   // Example LED Code
1222   //
1223     // // Using PE6 Caps Lock LED
1224     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1225     // {
1226     //     // Output high.
1227     //     DDRE |= (1<<6);
1228     //     PORTE |= (1<<6);
1229     // }
1230     // else
1231     // {
1232     //     // Output low.
1233     //     DDRE &= ~(1<<6);
1234     //     PORTE &= ~(1<<6);
1235     // }
1236
1237   led_set_kb(usb_led);
1238 }
1239
1240
1241 //------------------------------------------------------------------------------
1242 // Override these functions in your keymap file to play different tunes on
1243 // different events such as startup and bootloader jump
1244
1245 __attribute__ ((weak))
1246 void startup_user() {}
1247
1248 __attribute__ ((weak))
1249 void shutdown_user() {}
1250
1251 //------------------------------------------------------------------------------