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