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 #include "backlight.h"
  27 extern backlight_config_t backlight_config;
  28
  29 #ifdef FAUXCLICKY_ENABLE
  30 #include "fauxclicky.h"
  31 #endif
  32
  33 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
  34   switch (code) {
  35   case QK_MODS ... QK_MODS_MAX:
  36     break;
  37   default:
  38     return;
  39   }
  40
  41   if (code & QK_LCTL)
  42     f(KC_LCTL);
  43   if (code & QK_LSFT)
  44     f(KC_LSFT);
  45   if (code & QK_LALT)
  46     f(KC_LALT);
  47   if (code & QK_LGUI)
  48     f(KC_LGUI);
  49
  50   if (code < QK_RMODS_MIN) return;
  51
  52   if (code & QK_RCTL)
  53     f(KC_RCTL);
  54   if (code & QK_RSFT)
  55     f(KC_RSFT);
  56   if (code & QK_RALT)
  57     f(KC_RALT);
  58   if (code & QK_RGUI)
  59     f(KC_RGUI);
  60 }
  61
  62 static inline void qk_register_weak_mods(uint8_t kc) {
  63     add_weak_mods(MOD_BIT(kc));
  64     send_keyboard_report();
  65 }
  66
  67 static inline void qk_unregister_weak_mods(uint8_t kc) {
  68     del_weak_mods(MOD_BIT(kc));
  69     send_keyboard_report();
  70 }
  71
  72 static inline void qk_register_mods(uint8_t kc) {
  73     add_weak_mods(MOD_BIT(kc));
  74     send_keyboard_report();
  75 }
  76
  77 static inline void qk_unregister_mods(uint8_t kc) {
  78     del_weak_mods(MOD_BIT(kc));
  79     send_keyboard_report();
  80 }
  81
  82 void register_code16 (uint16_t code) {
  83   if (IS_MOD(code) || code == KC_NO) {
  84       do_code16 (code, qk_register_mods);
  85   } else {
  86       do_code16 (code, qk_register_weak_mods);
  87   }
  88   register_code (code);
  89 }
  90
  91 void unregister_code16 (uint16_t code) {
  92   unregister_code (code);
  93   if (IS_MOD(code) || code == KC_NO) {
  94       do_code16 (code, qk_unregister_mods);
  95   } else {
  96       do_code16 (code, qk_unregister_weak_mods);
  97   }
  98 }
  99
 100 __attribute__ ((weak))
 101 bool process_action_kb(keyrecord_t *record) {
 102   return true;
 103 }
 104
 105 __attribute__ ((weak))
 106 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
 107   return process_record_user(keycode, record);
 108 }
 109
 110 __attribute__ ((weak))
 111 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 112   return true;
 113 }
 114
 115 void reset_keyboard(void) {
 116   clear_keyboard();
 117 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
 118   music_all_notes_off();
 119   shutdown_user();
 120 #endif
 121   wait_ms(250);
 122 #ifdef CATERINA_BOOTLOADER
 123   *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
 124 #endif
 125   bootloader_jump();
 126 }
 127
 128 // Shift / paren setup
 129
 130 #ifndef LSPO_KEY
 131   #define LSPO_KEY KC_9
 132 #endif
 133 #ifndef RSPC_KEY
 134   #define RSPC_KEY KC_0
 135 #endif
 136
 137 static bool shift_interrupted[2] = {0, 0};
 138 static uint16_t scs_timer[2] = {0, 0};
 139
 140 bool process_record_quantum(keyrecord_t *record) {
 141
 142   /* This gets the keycode from the key pressed */
 143   keypos_t key = record->event.key;
 144   uint16_t keycode;
 145
 146   #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
 147     /* TODO: Use store_or_get_action() or a similar function. */
 148     if (!disable_action_cache) {
 149       uint8_t layer;
 150
 151       if (record->event.pressed) {
 152         layer = layer_switch_get_layer(key);
 153         update_source_layers_cache(key, layer);
 154       } else {
 155         layer = read_source_layers_cache(key);
 156       }
 157       keycode = keymap_key_to_keycode(layer, key);
 158     } else
 159   #endif
 160     keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
 161
 162     // This is how you use actions here
 163     // if (keycode == KC_LEAD) {
 164     //   action_t action;
 165     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
 166     //   process_action(record, action);
 167     //   return false;
 168     // }
 169
 170   if (!(
 171     process_record_kb(keycode, record) &&
 172   #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
 173     process_midi(keycode, record) &&
 174   #endif
 175   #ifdef AUDIO_ENABLE
 176     process_audio(keycode, record) &&
 177   #endif
 178   #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
 179     process_music(keycode, record) &&
 180   #endif
 181   #ifdef TAP_DANCE_ENABLE
 182     process_tap_dance(keycode, record) &&
 183   #endif
 184   #ifndef DISABLE_LEADER
 185     process_leader(keycode, record) &&
 186   #endif
 187   #ifndef DISABLE_CHORDING
 188     process_chording(keycode, record) &&
 189   #endif
 190   #ifdef COMBO_ENABLE
 191     process_combo(keycode, record) &&
 192   #endif
 193   #ifdef UNICODE_ENABLE
 194     process_unicode(keycode, record) &&
 195   #endif
 196   #ifdef UCIS_ENABLE
 197     process_ucis(keycode, record) &&
 198   #endif
 199   #ifdef PRINTING_ENABLE
 200     process_printer(keycode, record) &&
 201   #endif
 202   #ifdef UNICODEMAP_ENABLE
 203     process_unicode_map(keycode, record) &&
 204   #endif
 205       true)) {
 206     return false;
 207   }
 208
 209   // Shift / paren setup
 210
 211   switch(keycode) {
 212     case RESET:
 213       if (record->event.pressed) {
 214         reset_keyboard();
 215       }
 216           return false;
 217       break;
 218     case DEBUG:
 219       if (record->event.pressed) {
 220           print("\nDEBUG: enabled.\n");
 221           debug_enable = true;
 222       }
 223           return false;
 224       break;
 225   #ifdef FAUXCLICKY_ENABLE
 226   case FC_TOG:
 227     if (record->event.pressed) {
 228       FAUXCLICKY_TOGGLE;
 229     }
 230     return false;
 231     break;
 232   case FC_ON:
 233     if (record->event.pressed) {
 234       FAUXCLICKY_ON;
 235     }
 236     return false;
 237     break;
 238   case FC_OFF:
 239     if (record->event.pressed) {
 240       FAUXCLICKY_OFF;
 241     }
 242     return false;
 243     break;
 244   #endif
 245         #ifdef RGBLIGHT_ENABLE
 246         case RGB_TOG:
 247                 if (record->event.pressed) {
 248                         rgblight_toggle();
 249       }
 250           return false;
 251       break;
 252         case RGB_MOD:
 253                 if (record->event.pressed) {
 254                         rgblight_step();
 255       }
 256           return false;
 257       break;
 258         case RGB_HUI:
 259                 if (record->event.pressed) {
 260                         rgblight_increase_hue();
 261       }
 262           return false;
 263       break;
 264         case RGB_HUD:
 265                 if (record->event.pressed) {
 266                         rgblight_decrease_hue();
 267       }
 268           return false;
 269       break;
 270         case RGB_SAI:
 271                 if (record->event.pressed) {
 272                         rgblight_increase_sat();
 273       }
 274           return false;
 275       break;
 276         case RGB_SAD:
 277                 if (record->event.pressed) {
 278                         rgblight_decrease_sat();
 279       }
 280           return false;
 281       break;
 282         case RGB_VAI:
 283                 if (record->event.pressed) {
 284                         rgblight_increase_val();
 285       }
 286           return false;
 287       break;
 288         case RGB_VAD:
 289                 if (record->event.pressed) {
 290                         rgblight_decrease_val();
 291       }
 292           return false;
 293       break;
 294         #endif
 295     #ifdef PROTOCOL_LUFA
 296     case OUT_AUTO:
 297       if (record->event.pressed) {
 298         set_output(OUTPUT_AUTO);
 299       }
 300       return false;
 301       break;
 302     case OUT_USB:
 303       if (record->event.pressed) {
 304         set_output(OUTPUT_USB);
 305       }
 306       return false;
 307       break;
 308     #ifdef BLUETOOTH_ENABLE
 309     case OUT_BT:
 310       if (record->event.pressed) {
 311         set_output(OUTPUT_BLUETOOTH);
 312       }
 313       return false;
 314       break;
 315     #endif
 316     #endif
 317     case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
 318       if (record->event.pressed) {
 319         // MAGIC actions (BOOTMAGIC without the boot)
 320         if (!eeconfig_is_enabled()) {
 321             eeconfig_init();
 322         }
 323         /* keymap config */
 324         keymap_config.raw = eeconfig_read_keymap();
 325         switch (keycode)
 326         {
 327           case MAGIC_SWAP_CONTROL_CAPSLOCK:
 328             keymap_config.swap_control_capslock = true;
 329             break;
 330           case MAGIC_CAPSLOCK_TO_CONTROL:
 331             keymap_config.capslock_to_control = true;
 332             break;
 333           case MAGIC_SWAP_LALT_LGUI:
 334             keymap_config.swap_lalt_lgui = true;
 335             break;
 336           case MAGIC_SWAP_RALT_RGUI:
 337             keymap_config.swap_ralt_rgui = true;
 338             break;
 339           case MAGIC_NO_GUI:
 340             keymap_config.no_gui = true;
 341             break;
 342           case MAGIC_SWAP_GRAVE_ESC:
 343             keymap_config.swap_grave_esc = true;
 344             break;
 345           case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 346             keymap_config.swap_backslash_backspace = true;
 347             break;
 348           case MAGIC_HOST_NKRO:
 349             keymap_config.nkro = true;
 350             break;
 351           case MAGIC_SWAP_ALT_GUI:
 352             keymap_config.swap_lalt_lgui = true;
 353             keymap_config.swap_ralt_rgui = true;
 354             break;
 355           case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 356             keymap_config.swap_control_capslock = false;
 357             break;
 358           case MAGIC_UNCAPSLOCK_TO_CONTROL:
 359             keymap_config.capslock_to_control = false;
 360             break;
 361           case MAGIC_UNSWAP_LALT_LGUI:
 362             keymap_config.swap_lalt_lgui = false;
 363             break;
 364           case MAGIC_UNSWAP_RALT_RGUI:
 365             keymap_config.swap_ralt_rgui = false;
 366             break;
 367           case MAGIC_UNNO_GUI:
 368             keymap_config.no_gui = false;
 369             break;
 370           case MAGIC_UNSWAP_GRAVE_ESC:
 371             keymap_config.swap_grave_esc = false;
 372             break;
 373           case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 374             keymap_config.swap_backslash_backspace = false;
 375             break;
 376           case MAGIC_UNHOST_NKRO:
 377             keymap_config.nkro = false;
 378             break;
 379           case MAGIC_UNSWAP_ALT_GUI:
 380             keymap_config.swap_lalt_lgui = false;
 381             keymap_config.swap_ralt_rgui = false;
 382             break;
 383           case MAGIC_TOGGLE_NKRO:
 384             keymap_config.nkro = !keymap_config.nkro;
 385             break;
 386           default:
 387             break;
 388         }
 389         eeconfig_update_keymap(keymap_config.raw);
 390         clear_keyboard(); // clear to prevent stuck keys
 391
 392         return false;
 393       }
 394       break;
 395     case KC_LSPO: {
 396       if (record->event.pressed) {
 397         shift_interrupted[0] = false;
 398         scs_timer[0] = timer_read ();
 399         register_mods(MOD_BIT(KC_LSFT));
 400       }
 401       else {
 402         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 403           if (get_mods() & MOD_BIT(KC_RSFT)) {
 404             shift_interrupted[0] = true;
 405             shift_interrupted[1] = true;
 406           }
 407         #endif
 408         if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
 409           register_code(LSPO_KEY);
 410           unregister_code(LSPO_KEY);
 411         }
 412         unregister_mods(MOD_BIT(KC_LSFT));
 413       }
 414       return false;
 415       // break;
 416     }
 417
 418     case KC_RSPC: {
 419       if (record->event.pressed) {
 420         shift_interrupted[1] = false;
 421         scs_timer[1] = timer_read ();
 422         register_mods(MOD_BIT(KC_RSFT));
 423       }
 424       else {
 425         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 426           if (get_mods() & MOD_BIT(KC_LSFT)) {
 427             shift_interrupted[0] = true;
 428             shift_interrupted[1] = true;
 429           }
 430         #endif
 431         if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 432           register_code(RSPC_KEY);
 433           unregister_code(RSPC_KEY);
 434         }
 435         unregister_mods(MOD_BIT(KC_RSFT));
 436       }
 437       return false;
 438       // break;
 439     }
 440     case GRAVE_ESC: {
 441       void (*method)(uint8_t) = (record->event.pressed) ? &add_key : &del_key;
 442       uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
 443                                       |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
 444
 445       method(shifted ? KC_GRAVE : KC_ESCAPE);
 446       send_keyboard_report();
 447     }
 448     default: {
 449       shift_interrupted[0] = true;
 450       shift_interrupted[1] = true;
 451       break;
 452     }
 453   }
 454
 455   return process_action_kb(record);
 456 }
 457
 458 #if defined SENDSTRING_JIS_KEYCODE
 459 /* for users with JIS keyboards */
 460 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 461     0, 0, 0, 0, 0, 0, 0, 0,
 462     0, 0, 0, 0, 0, 0, 0, 0,
 463     0, 0, 0, 0, 0, 0, 0, 0,
 464     0, 0, 0, 0, 0, 0, 0, 0,
 465     0, 1, 1, 1, 1, 1, 1, 1,
 466     1, 1, 1, 1, 0, 0, 0, 0,
 467     0, 0, 0, 0, 0, 0, 0, 0,
 468     0, 0, 0, 0, 1, 1, 1, 1,
 469     0, 1, 1, 1, 1, 1, 1, 1,
 470     1, 1, 1, 1, 1, 1, 1, 1,
 471     1, 1, 1, 1, 1, 1, 1, 1,
 472     1, 1, 1, 0, 0, 0, 0, 1,
 473     1, 0, 0, 0, 0, 0, 0, 0,
 474     0, 0, 0, 0, 0, 0, 0, 0,
 475     0, 0, 0, 0, 0, 0, 0, 0,
 476     0, 0, 0, 1, 1, 1, 1, 0
 477 };
 478 #else
 479 /* for standard keycodes */
 480 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 481     0, 0, 0, 0, 0, 0, 0, 0,
 482     0, 0, 0, 0, 0, 0, 0, 0,
 483     0, 0, 0, 0, 0, 0, 0, 0,
 484     0, 0, 0, 0, 0, 0, 0, 0,
 485     0, 1, 1, 1, 1, 1, 1, 0,
 486     1, 1, 1, 1, 0, 0, 0, 0,
 487     0, 0, 0, 0, 0, 0, 0, 0,
 488     0, 0, 1, 0, 1, 0, 1, 1,
 489     1, 1, 1, 1, 1, 1, 1, 1,
 490     1, 1, 1, 1, 1, 1, 1, 1,
 491     1, 1, 1, 1, 1, 1, 1, 1,
 492     1, 1, 1, 0, 0, 0, 1, 1,
 493     0, 0, 0, 0, 0, 0, 0, 0,
 494     0, 0, 0, 0, 0, 0, 0, 0,
 495     0, 0, 0, 0, 0, 0, 0, 0,
 496     0, 0, 0, 1, 1, 1, 1, 0
 497 };
 498 #endif
 499
 500 #if defined SENDSTRING_JIS_KEYCODE
 501 /* for users with JIS keyboards */
 502 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 503     0, 0, 0, 0, 0, 0, 0, 0,
 504     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 505     0, 0, 0, 0, 0, 0, 0, 0,
 506     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 507     KC_SPC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 508     KC_8, KC_9, KC_QUOT, KC_SCLN, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 509     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 510     KC_8, KC_9, KC_QUOT, KC_SCLN, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 511     KC_LBRC, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 512     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 513     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 514     KC_X, KC_Y, KC_Z, KC_RBRC, KC_JYEN, KC_BSLS, KC_EQL, KC_RO,
 515     KC_LBRC, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 516     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 517     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 518     KC_X, KC_Y, KC_Z, KC_RBRC, KC_JYEN, KC_BSLS, KC_EQL, KC_DEL,
 519 };
 520 #elif defined SENDSTRING_COLEMAK_KEYCODE
 521 /* for users whose OSes are set to Colemak */
 522 #include "keymap_colemak.h"
 523 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 524     0, 0, 0, 0, 0, 0, 0, 0,
 525     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 526     0, 0, 0, 0, 0, 0, 0, 0,
 527     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 528     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 529     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 530     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 531     KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 532     KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
 533     CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
 534     CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
 535     CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 536     KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
 537     CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
 538     CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
 539     CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 540 };
 541 #elif defined SENDSTRING_DVORAK_KEYCODE
 542 /* for users whose OSes are set to Dvorak */
 543 #include "keymap_dvorak.h"
 544 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 545     0, 0, 0, 0, 0, 0, 0, 0,
 546     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 547     0, 0, 0, 0, 0, 0, 0, 0,
 548     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 549     KC_SPC, DV_1, DV_QUOT, DV_3, DV_4, DV_5, DV_7, DV_QUOT,
 550     DV_9, DV_0, DV_8, DV_EQL, DV_COMM, DV_MINS, DV_DOT, DV_SLSH,
 551     DV_0, DV_1, DV_2, DV_3, DV_4, DV_5, DV_6, DV_7,
 552     DV_8, DV_9, DV_SCLN, DV_SCLN, DV_COMM, DV_EQL, DV_DOT, DV_SLSH,
 553     DV_2, DV_A, DV_B, DV_C, DV_D, DV_E, DV_F, DV_G,
 554     DV_H, DV_I, DV_J, DV_K, DV_L, DV_M, DV_N, DV_O,
 555     DV_P, DV_Q, DV_R, DV_S, DV_T, DV_U, DV_V, DV_W,
 556     DV_X, DV_Y, DV_Z, DV_LBRC, DV_BSLS, DV_RBRC, DV_6, DV_MINS,
 557     DV_GRV, DV_A, DV_B, DV_C, DV_D, DV_E, DV_F, DV_G,
 558     DV_H, DV_I, DV_J, DV_K, DV_L, DV_M, DV_N, DV_O,
 559     DV_P, DV_Q, DV_R, DV_S, DV_T, DV_U, DV_V, DV_W,
 560     DV_X, DV_Y, DV_Z, DV_LBRC, DV_BSLS, DV_RBRC, DV_GRV, KC_DEL
 561 };
 562 #else
 563 /* For users with default keyboard layout in OS */
 564 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 565     0, 0, 0, 0, 0, 0, 0, 0,
 566     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 567     0, 0, 0, 0, 0, 0, 0, 0,
 568     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 569     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 570     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 571     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 572     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 573     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 574     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 575     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 576     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 577     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 578     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 579     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 580     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 581 };
 582 #endif
 583
 584 void send_string(const char *str) {
 585   send_string_with_delay(str, 0);
 586 }
 587
 588 void send_string_with_delay(const char *str, uint8_t interval) {
 589     while (1) {
 590         uint8_t keycode;
 591         uint8_t ascii_code = pgm_read_byte(str);
 592         if (!ascii_code) break;
 593         keycode = pgm_read_byte(&ascii_to_keycode_lut[ascii_code]);
 594         if (pgm_read_byte(&ascii_to_shift_lut[ascii_code])) {
 595             register_code(KC_LSFT);
 596             register_code(keycode);
 597             unregister_code(keycode);
 598             unregister_code(KC_LSFT);
 599         }
 600         else {
 601             register_code(keycode);
 602             unregister_code(keycode);
 603         }
 604         ++str;
 605         // interval
 606         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 607     }
 608 }
 609
 610 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 611   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
 612     layer_on(layer3);
 613   } else {
 614     layer_off(layer3);
 615   }
 616 }
 617
 618 void tap_random_base64(void) {
 619   #if defined(__AVR_ATmega32U4__)
 620     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 621   #else
 622     uint8_t key = rand() % 64;
 623   #endif
 624   switch (key) {
 625     case 0 ... 25:
 626       register_code(KC_LSFT);
 627       register_code(key + KC_A);
 628       unregister_code(key + KC_A);
 629       unregister_code(KC_LSFT);
 630       break;
 631     case 26 ... 51:
 632       register_code(key - 26 + KC_A);
 633       unregister_code(key - 26 + KC_A);
 634       break;
 635     case 52:
 636       register_code(KC_0);
 637       unregister_code(KC_0);
 638       break;
 639     case 53 ... 61:
 640       register_code(key - 53 + KC_1);
 641       unregister_code(key - 53 + KC_1);
 642       break;
 643     case 62:
 644       register_code(KC_LSFT);
 645       register_code(KC_EQL);
 646       unregister_code(KC_EQL);
 647       unregister_code(KC_LSFT);
 648       break;
 649     case 63:
 650       register_code(KC_SLSH);
 651       unregister_code(KC_SLSH);
 652       break;
 653   }
 654 }
 655
 656 void matrix_init_quantum() {
 657   #ifdef BACKLIGHT_ENABLE
 658     backlight_init_ports();
 659   #endif
 660   matrix_init_kb();
 661 }
 662
 663 void matrix_scan_quantum() {
 664   #ifdef AUDIO_ENABLE
 665     matrix_scan_music();
 666   #endif
 667
 668   #ifdef TAP_DANCE_ENABLE
 669     matrix_scan_tap_dance();
 670   #endif
 671
 672   #ifdef COMBO_ENABLE
 673     matrix_scan_combo();
 674   #endif
 675
 676   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 677     backlight_task();
 678   #endif
 679
 680   matrix_scan_kb();
 681 }
 682
 683 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 684
 685 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 686
 687 #if BACKLIGHT_PIN == B7
 688 #  define COM1x1 COM1C1
 689 #  define OCR1x  OCR1C
 690 #elif BACKLIGHT_PIN == B6
 691 #  define COM1x1 COM1B1
 692 #  define OCR1x  OCR1B
 693 #elif BACKLIGHT_PIN == B5
 694 #  define COM1x1 COM1A1
 695 #  define OCR1x  OCR1A
 696 #else
 697 #  define NO_BACKLIGHT_CLOCK
 698 #endif
 699
 700 #ifndef BACKLIGHT_ON_STATE
 701 #define BACKLIGHT_ON_STATE 0
 702 #endif
 703
 704 __attribute__ ((weak))
 705 void backlight_init_ports(void)
 706 {
 707
 708   // Setup backlight pin as output and output to on state.
 709   // DDRx |= n
 710   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 711   #if BACKLIGHT_ON_STATE == 0
 712     // PORTx &= ~n
 713     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 714   #else
 715     // PORTx |= n
 716     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 717   #endif
 718
 719   #ifndef NO_BACKLIGHT_CLOCK
 720     // Use full 16-bit resolution.
 721     ICR1 = 0xFFFF;
 722
 723     // I could write a wall of text here to explain... but TL;DW
 724     // Go read the ATmega32u4 datasheet.
 725     // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
 726
 727     // Pin PB7 = OCR1C (Timer 1, Channel C)
 728     // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
 729     // (i.e. start high, go low when counter matches.)
 730     // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
 731     // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
 732
 733     TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
 734     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
 735   #endif
 736
 737   backlight_init();
 738   #ifdef BACKLIGHT_BREATHING
 739     breathing_defaults();
 740   #endif
 741 }
 742
 743 __attribute__ ((weak))
 744 void backlight_set(uint8_t level)
 745 {
 746   // Prevent backlight blink on lowest level
 747   // #if BACKLIGHT_ON_STATE == 0
 748   //   // PORTx &= ~n
 749   //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 750   // #else
 751   //   // PORTx |= n
 752   //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 753   // #endif
 754
 755   if ( level == 0 ) {
 756     #ifndef NO_BACKLIGHT_CLOCK
 757       // Turn off PWM control on backlight pin, revert to output low.
 758       TCCR1A &= ~(_BV(COM1x1));
 759       OCR1x = 0x0;
 760     #else
 761       // #if BACKLIGHT_ON_STATE == 0
 762       //   // PORTx |= n
 763       //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 764       // #else
 765       //   // PORTx &= ~n
 766       //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 767       // #endif
 768     #endif
 769   }
 770   #ifndef NO_BACKLIGHT_CLOCK
 771     else if ( level == BACKLIGHT_LEVELS ) {
 772       // Turn on PWM control of backlight pin
 773       TCCR1A |= _BV(COM1x1);
 774       // Set the brightness
 775       OCR1x = 0xFFFF;
 776     }
 777     else {
 778       // Turn on PWM control of backlight pin
 779       TCCR1A |= _BV(COM1x1);
 780       // Set the brightness
 781       OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
 782     }
 783   #endif
 784
 785   #ifdef BACKLIGHT_BREATHING
 786     breathing_intensity_default();
 787   #endif
 788 }
 789
 790 uint8_t backlight_tick = 0;
 791
 792 void backlight_task(void) {
 793   #ifdef NO_BACKLIGHT_CLOCK
 794   if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 795     #if BACKLIGHT_ON_STATE == 0
 796       // PORTx &= ~n
 797       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 798     #else
 799       // PORTx |= n
 800       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 801     #endif
 802   } else {
 803     #if BACKLIGHT_ON_STATE == 0
 804       // PORTx |= n
 805       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 806     #else
 807       // PORTx &= ~n
 808       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 809     #endif
 810   }
 811   backlight_tick = (backlight_tick + 1) % 16;
 812   #endif
 813 }
 814
 815 #ifdef BACKLIGHT_BREATHING
 816
 817 #define BREATHING_NO_HALT  0
 818 #define BREATHING_HALT_OFF 1
 819 #define BREATHING_HALT_ON  2
 820
 821 static uint8_t breath_intensity;
 822 static uint8_t breath_speed;
 823 static uint16_t breathing_index;
 824 static uint8_t breathing_halt;
 825
 826 void breathing_enable(void)
 827 {
 828     if (get_backlight_level() == 0)
 829     {
 830         breathing_index = 0;
 831     }
 832     else
 833     {
 834         // Set breathing_index to be at the midpoint (brightest point)
 835         breathing_index = 0x20 << breath_speed;
 836     }
 837
 838     breathing_halt = BREATHING_NO_HALT;
 839
 840     // Enable breathing interrupt
 841     TIMSK1 |= _BV(OCIE1A);
 842 }
 843
 844 void breathing_pulse(void)
 845 {
 846     if (get_backlight_level() == 0)
 847     {
 848         breathing_index = 0;
 849     }
 850     else
 851     {
 852         // Set breathing_index to be at the midpoint + 1 (brightest point)
 853         breathing_index = 0x21 << breath_speed;
 854     }
 855
 856     breathing_halt = BREATHING_HALT_ON;
 857
 858     // Enable breathing interrupt
 859     TIMSK1 |= _BV(OCIE1A);
 860 }
 861
 862 void breathing_disable(void)
 863 {
 864     // Disable breathing interrupt
 865     TIMSK1 &= ~_BV(OCIE1A);
 866     backlight_set(get_backlight_level());
 867 }
 868
 869 void breathing_self_disable(void)
 870 {
 871     if (get_backlight_level() == 0)
 872     {
 873         breathing_halt = BREATHING_HALT_OFF;
 874     }
 875     else
 876     {
 877         breathing_halt = BREATHING_HALT_ON;
 878     }
 879
 880     //backlight_set(get_backlight_level());
 881 }
 882
 883 void breathing_toggle(void)
 884 {
 885     if (!is_breathing())
 886     {
 887         if (get_backlight_level() == 0)
 888         {
 889             breathing_index = 0;
 890         }
 891         else
 892         {
 893             // Set breathing_index to be at the midpoint + 1 (brightest point)
 894             breathing_index = 0x21 << breath_speed;
 895         }
 896
 897         breathing_halt = BREATHING_NO_HALT;
 898     }
 899
 900     // Toggle breathing interrupt
 901     TIMSK1 ^= _BV(OCIE1A);
 902
 903     // Restore backlight level
 904     if (!is_breathing())
 905     {
 906         backlight_set(get_backlight_level());
 907     }
 908 }
 909
 910 bool is_breathing(void)
 911 {
 912     return (TIMSK1 && _BV(OCIE1A));
 913 }
 914
 915 void breathing_intensity_default(void)
 916 {
 917     //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
 918     breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
 919 }
 920
 921 void breathing_intensity_set(uint8_t value)
 922 {
 923     breath_intensity = value;
 924 }
 925
 926 void breathing_speed_default(void)
 927 {
 928     breath_speed = 4;
 929 }
 930
 931 void breathing_speed_set(uint8_t value)
 932 {
 933     bool is_breathing_now = is_breathing();
 934     uint8_t old_breath_speed = breath_speed;
 935
 936     if (is_breathing_now)
 937     {
 938         // Disable breathing interrupt
 939         TIMSK1 &= ~_BV(OCIE1A);
 940     }
 941
 942     breath_speed = value;
 943
 944     if (is_breathing_now)
 945     {
 946         // Adjust index to account for new speed
 947         breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
 948
 949         // Enable breathing interrupt
 950         TIMSK1 |= _BV(OCIE1A);
 951     }
 952
 953 }
 954
 955 void breathing_speed_inc(uint8_t value)
 956 {
 957     if ((uint16_t)(breath_speed - value) > 10 )
 958     {
 959         breathing_speed_set(0);
 960     }
 961     else
 962     {
 963         breathing_speed_set(breath_speed - value);
 964     }
 965 }
 966
 967 void breathing_speed_dec(uint8_t value)
 968 {
 969     if ((uint16_t)(breath_speed + value) > 10 )
 970     {
 971         breathing_speed_set(10);
 972     }
 973     else
 974     {
 975         breathing_speed_set(breath_speed + value);
 976     }
 977 }
 978
 979 void breathing_defaults(void)
 980 {
 981     breathing_intensity_default();
 982     breathing_speed_default();
 983     breathing_halt = BREATHING_NO_HALT;
 984 }
 985
 986 /* Breathing Sleep LED brighness(PWM On period) table
 987  * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
 988  *
 989  * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
 990  * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
 991  */
 992 static const uint8_t breathing_table[64] PROGMEM = {
 993   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   2,   4,   6,  10,
 994  15,  23,  32,  44,  58,  74,  93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
 995 255, 252, 245, 233, 218, 199, 179, 157, 135, 113,  93,  74,  58,  44,  32,  23,
 996  15,  10,   6,   4,   2,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 997 };
 998
 999 ISR(TIMER1_COMPA_vect)
1000 {
1001     // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
1002
1003
1004     uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
1005
1006     if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
1007     {
1008         // Disable breathing interrupt
1009         TIMSK1 &= ~_BV(OCIE1A);
1010     }
1011
1012     OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
1013
1014 }
1015
1016
1017
1018 #endif // breathing
1019
1020 #else // backlight
1021
1022 __attribute__ ((weak))
1023 void backlight_init_ports(void)
1024 {
1025
1026 }
1027
1028 __attribute__ ((weak))
1029 void backlight_set(uint8_t level)
1030 {
1031
1032 }
1033
1034 #endif // backlight
1035
1036
1037 // Functions for spitting out values
1038 //
1039
1040 void send_dword(uint32_t number) { // this might not actually work
1041     uint16_t word = (number >> 16);
1042     send_word(word);
1043     send_word(number & 0xFFFFUL);
1044 }
1045
1046 void send_word(uint16_t number) {
1047     uint8_t byte = number >> 8;
1048     send_byte(byte);
1049     send_byte(number & 0xFF);
1050 }
1051
1052 void send_byte(uint8_t number) {
1053     uint8_t nibble = number >> 4;
1054     send_nibble(nibble);
1055     send_nibble(number & 0xF);
1056 }
1057
1058 void send_nibble(uint8_t number) {
1059     switch (number) {
1060         case 0:
1061             register_code(KC_0);
1062             unregister_code(KC_0);
1063             break;
1064         case 1 ... 9:
1065             register_code(KC_1 + (number - 1));
1066             unregister_code(KC_1 + (number - 1));
1067             break;
1068         case 0xA ... 0xF:
1069             register_code(KC_A + (number - 0xA));
1070             unregister_code(KC_A + (number - 0xA));
1071             break;
1072     }
1073 }
1074
1075
1076 __attribute__((weak))
1077 uint16_t hex_to_keycode(uint8_t hex)
1078 {
1079   if (hex == 0x0) {
1080     return KC_0;
1081   } else if (hex < 0xA) {
1082     return KC_1 + (hex - 0x1);
1083   } else {
1084     return KC_A + (hex - 0xA);
1085   }
1086 }
1087
1088 void api_send_unicode(uint32_t unicode) {
1089 #ifdef API_ENABLE
1090     uint8_t chunk[4];
1091     dword_to_bytes(unicode, chunk);
1092     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1093 #endif
1094 }
1095
1096 __attribute__ ((weak))
1097 void led_set_user(uint8_t usb_led) {
1098
1099 }
1100
1101 __attribute__ ((weak))
1102 void led_set_kb(uint8_t usb_led) {
1103     led_set_user(usb_led);
1104 }
1105
1106 __attribute__ ((weak))
1107 void led_init_ports(void)
1108 {
1109
1110 }
1111
1112 __attribute__ ((weak))
1113 void led_set(uint8_t usb_led)
1114 {
1115
1116   // Example LED Code
1117   //
1118     // // Using PE6 Caps Lock LED
1119     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1120     // {
1121     //     // Output high.
1122     //     DDRE |= (1<<6);
1123     //     PORTE |= (1<<6);
1124     // }
1125     // else
1126     // {
1127     //     // Output low.
1128     //     DDRE &= ~(1<<6);
1129     //     PORTE &= ~(1<<6);
1130     // }
1131
1132   led_set_kb(usb_led);
1133 }
1134
1135
1136 //------------------------------------------------------------------------------
1137 // Override these functions in your keymap file to play different tunes on
1138 // different events such as startup and bootloader jump
1139
1140 __attribute__ ((weak))
1141 void startup_user() {}
1142
1143 __attribute__ ((weak))
1144 void shutdown_user() {}
1145
1146 //------------------------------------------------------------------------------