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