quantum/quantum.c

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