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     default: {
 441       shift_interrupted[0] = true;
 442       shift_interrupted[1] = true;
 443       break;
 444     }
 445   }
 446
 447   return process_action_kb(record);
 448 }
 449
 450 const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
 451     0, 0, 0, 0, 0, 0, 0, 0,
 452     0, 0, 0, 0, 0, 0, 0, 0,
 453     0, 0, 0, 0, 0, 0, 0, 0,
 454     0, 0, 0, 0, 0, 0, 0, 0,
 455     0, 1, 1, 1, 1, 1, 1, 0,
 456     1, 1, 1, 1, 0, 0, 0, 0,
 457     0, 0, 0, 0, 0, 0, 0, 0,
 458     0, 0, 1, 0, 1, 0, 1, 1,
 459     1, 1, 1, 1, 1, 1, 1, 1,
 460     1, 1, 1, 1, 1, 1, 1, 1,
 461     1, 1, 1, 1, 1, 1, 1, 1,
 462     1, 1, 1, 0, 0, 0, 1, 1,
 463     0, 0, 0, 0, 0, 0, 0, 0,
 464     0, 0, 0, 0, 0, 0, 0, 0,
 465     0, 0, 0, 0, 0, 0, 0, 0,
 466     0, 0, 0, 1, 1, 1, 1, 0
 467 };
 468
 469 const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
 470     0, 0, 0, 0, 0, 0, 0, 0,
 471     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 472     0, 0, 0, 0, 0, 0, 0, 0,
 473     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 474     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 475     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 476     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 477     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 478     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 479     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 480     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 481     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 482     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 483     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 484     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 485     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 486 };
 487
 488 /* for users whose OSes are set to Colemak */
 489 #if 0
 490 #include "keymap_colemak.h"
 491
 492 const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
 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, 0, 0, 0, 0, 0,
 497     0, 1, 1, 1, 1, 1, 1, 0,
 498     1, 1, 1, 1, 0, 0, 0, 0,
 499     0, 0, 0, 0, 0, 0, 0, 0,
 500     0, 0, 1, 0, 1, 0, 1, 1,
 501     1, 1, 1, 1, 1, 1, 1, 1,
 502     1, 1, 1, 1, 1, 1, 1, 1,
 503     1, 1, 1, 1, 1, 1, 1, 1,
 504     1, 1, 1, 0, 0, 0, 1, 1,
 505     0, 0, 0, 0, 0, 0, 0, 0,
 506     0, 0, 0, 0, 0, 0, 0, 0,
 507     0, 0, 0, 0, 0, 0, 0, 0,
 508     0, 0, 0, 1, 1, 1, 1, 0
 509 };
 510
 511 const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
 512     0, 0, 0, 0, 0, 0, 0, 0,
 513     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 514     0, 0, 0, 0, 0, 0, 0, 0,
 515     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 516     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 517     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 518     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 519     KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 520     KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
 521     CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
 522     CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
 523     CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 524     KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
 525     CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
 526     CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
 527     CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 528 };
 529
 530 #endif
 531
 532 void send_string(const char *str) {
 533     while (1) {
 534         uint8_t keycode;
 535         uint8_t ascii_code = pgm_read_byte(str);
 536         if (!ascii_code) break;
 537         keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
 538         if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
 539             register_code(KC_LSFT);
 540             register_code(keycode);
 541             unregister_code(keycode);
 542             unregister_code(KC_LSFT);
 543         }
 544         else {
 545             register_code(keycode);
 546             unregister_code(keycode);
 547         }
 548         ++str;
 549     }
 550 }
 551
 552 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 553   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
 554     layer_on(layer3);
 555   } else {
 556     layer_off(layer3);
 557   }
 558 }
 559
 560 void tap_random_base64(void) {
 561   #if defined(__AVR_ATmega32U4__)
 562     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
 563   #else
 564     uint8_t key = rand() % 64;
 565   #endif
 566   switch (key) {
 567     case 0 ... 25:
 568       register_code(KC_LSFT);
 569       register_code(key + KC_A);
 570       unregister_code(key + KC_A);
 571       unregister_code(KC_LSFT);
 572       break;
 573     case 26 ... 51:
 574       register_code(key - 26 + KC_A);
 575       unregister_code(key - 26 + KC_A);
 576       break;
 577     case 52:
 578       register_code(KC_0);
 579       unregister_code(KC_0);
 580       break;
 581     case 53 ... 61:
 582       register_code(key - 53 + KC_1);
 583       unregister_code(key - 53 + KC_1);
 584       break;
 585     case 62:
 586       register_code(KC_LSFT);
 587       register_code(KC_EQL);
 588       unregister_code(KC_EQL);
 589       unregister_code(KC_LSFT);
 590       break;
 591     case 63:
 592       register_code(KC_SLSH);
 593       unregister_code(KC_SLSH);
 594       break;
 595   }
 596 }
 597
 598 void matrix_init_quantum() {
 599   #ifdef BACKLIGHT_ENABLE
 600     backlight_init_ports();
 601   #endif
 602   matrix_init_kb();
 603 }
 604
 605 void matrix_scan_quantum() {
 606   #ifdef AUDIO_ENABLE
 607     matrix_scan_music();
 608   #endif
 609
 610   #ifdef TAP_DANCE_ENABLE
 611     matrix_scan_tap_dance();
 612   #endif
 613
 614   #ifdef COMBO_ENABLE
 615     matrix_scan_combo();
 616   #endif
 617
 618   #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 619     backlight_task();
 620   #endif
 621
 622   matrix_scan_kb();
 623 }
 624
 625 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 626
 627 static const uint8_t backlight_pin = BACKLIGHT_PIN;
 628
 629 #if BACKLIGHT_PIN == B7
 630 #  define COM1x1 COM1C1
 631 #  define OCR1x  OCR1C
 632 #elif BACKLIGHT_PIN == B6
 633 #  define COM1x1 COM1B1
 634 #  define OCR1x  OCR1B
 635 #elif BACKLIGHT_PIN == B5
 636 #  define COM1x1 COM1A1
 637 #  define OCR1x  OCR1A
 638 #else
 639 #  define NO_BACKLIGHT_CLOCK
 640 #endif
 641
 642 #ifndef BACKLIGHT_ON_STATE
 643 #define BACKLIGHT_ON_STATE 0
 644 #endif
 645
 646 __attribute__ ((weak))
 647 void backlight_init_ports(void)
 648 {
 649
 650   // Setup backlight pin as output and output to on state.
 651   // DDRx |= n
 652   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
 653   #if BACKLIGHT_ON_STATE == 0
 654     // PORTx &= ~n
 655     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 656   #else
 657     // PORTx |= n
 658     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 659   #endif
 660
 661   #ifndef NO_BACKLIGHT_CLOCK
 662     // Use full 16-bit resolution.
 663     ICR1 = 0xFFFF;
 664
 665     // I could write a wall of text here to explain... but TL;DW
 666     // Go read the ATmega32u4 datasheet.
 667     // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
 668
 669     // Pin PB7 = OCR1C (Timer 1, Channel C)
 670     // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
 671     // (i.e. start high, go low when counter matches.)
 672     // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
 673     // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
 674
 675     TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
 676     TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
 677   #endif
 678
 679   backlight_init();
 680   #ifdef BACKLIGHT_BREATHING
 681     breathing_defaults();
 682   #endif
 683 }
 684
 685 __attribute__ ((weak))
 686 void backlight_set(uint8_t level)
 687 {
 688   // Prevent backlight blink on lowest level
 689   // #if BACKLIGHT_ON_STATE == 0
 690   //   // PORTx &= ~n
 691   //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 692   // #else
 693   //   // PORTx |= n
 694   //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 695   // #endif
 696
 697   if ( level == 0 ) {
 698     #ifndef NO_BACKLIGHT_CLOCK
 699       // Turn off PWM control on backlight pin, revert to output low.
 700       TCCR1A &= ~(_BV(COM1x1));
 701       OCR1x = 0x0;
 702     #else
 703       // #if BACKLIGHT_ON_STATE == 0
 704       //   // PORTx |= n
 705       //   _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 706       // #else
 707       //   // PORTx &= ~n
 708       //   _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 709       // #endif
 710     #endif
 711   }
 712   #ifndef NO_BACKLIGHT_CLOCK
 713     else if ( level == BACKLIGHT_LEVELS ) {
 714       // Turn on PWM control of backlight pin
 715       TCCR1A |= _BV(COM1x1);
 716       // Set the brightness
 717       OCR1x = 0xFFFF;
 718     }
 719     else {
 720       // Turn on PWM control of backlight pin
 721       TCCR1A |= _BV(COM1x1);
 722       // Set the brightness
 723       OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
 724     }
 725   #endif
 726
 727   #ifdef BACKLIGHT_BREATHING
 728     breathing_intensity_default();
 729   #endif
 730 }
 731
 732 uint8_t backlight_tick = 0;
 733
 734 void backlight_task(void) {
 735   #ifdef NO_BACKLIGHT_CLOCK
 736   if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
 737     #if BACKLIGHT_ON_STATE == 0
 738       // PORTx &= ~n
 739       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 740     #else
 741       // PORTx |= n
 742       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 743     #endif
 744   } else {
 745     #if BACKLIGHT_ON_STATE == 0
 746       // PORTx |= n
 747       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
 748     #else
 749       // PORTx &= ~n
 750       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
 751     #endif
 752   }
 753   backlight_tick = (backlight_tick + 1) % 16;
 754   #endif
 755 }
 756
 757 #ifdef BACKLIGHT_BREATHING
 758
 759 #define BREATHING_NO_HALT  0
 760 #define BREATHING_HALT_OFF 1
 761 #define BREATHING_HALT_ON  2
 762
 763 static uint8_t breath_intensity;
 764 static uint8_t breath_speed;
 765 static uint16_t breathing_index;
 766 static uint8_t breathing_halt;
 767
 768 void breathing_enable(void)
 769 {
 770     if (get_backlight_level() == 0)
 771     {
 772         breathing_index = 0;
 773     }
 774     else
 775     {
 776         // Set breathing_index to be at the midpoint (brightest point)
 777         breathing_index = 0x20 << breath_speed;
 778     }
 779
 780     breathing_halt = BREATHING_NO_HALT;
 781
 782     // Enable breathing interrupt
 783     TIMSK1 |= _BV(OCIE1A);
 784 }
 785
 786 void breathing_pulse(void)
 787 {
 788     if (get_backlight_level() == 0)
 789     {
 790         breathing_index = 0;
 791     }
 792     else
 793     {
 794         // Set breathing_index to be at the midpoint + 1 (brightest point)
 795         breathing_index = 0x21 << breath_speed;
 796     }
 797
 798     breathing_halt = BREATHING_HALT_ON;
 799
 800     // Enable breathing interrupt
 801     TIMSK1 |= _BV(OCIE1A);
 802 }
 803
 804 void breathing_disable(void)
 805 {
 806     // Disable breathing interrupt
 807     TIMSK1 &= ~_BV(OCIE1A);
 808     backlight_set(get_backlight_level());
 809 }
 810
 811 void breathing_self_disable(void)
 812 {
 813     if (get_backlight_level() == 0)
 814     {
 815         breathing_halt = BREATHING_HALT_OFF;
 816     }
 817     else
 818     {
 819         breathing_halt = BREATHING_HALT_ON;
 820     }
 821
 822     //backlight_set(get_backlight_level());
 823 }
 824
 825 void breathing_toggle(void)
 826 {
 827     if (!is_breathing())
 828     {
 829         if (get_backlight_level() == 0)
 830         {
 831             breathing_index = 0;
 832         }
 833         else
 834         {
 835             // Set breathing_index to be at the midpoint + 1 (brightest point)
 836             breathing_index = 0x21 << breath_speed;
 837         }
 838
 839         breathing_halt = BREATHING_NO_HALT;
 840     }
 841
 842     // Toggle breathing interrupt
 843     TIMSK1 ^= _BV(OCIE1A);
 844
 845     // Restore backlight level
 846     if (!is_breathing())
 847     {
 848         backlight_set(get_backlight_level());
 849     }
 850 }
 851
 852 bool is_breathing(void)
 853 {
 854     return (TIMSK1 && _BV(OCIE1A));
 855 }
 856
 857 void breathing_intensity_default(void)
 858 {
 859     //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
 860     breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
 861 }
 862
 863 void breathing_intensity_set(uint8_t value)
 864 {
 865     breath_intensity = value;
 866 }
 867
 868 void breathing_speed_default(void)
 869 {
 870     breath_speed = 4;
 871 }
 872
 873 void breathing_speed_set(uint8_t value)
 874 {
 875     bool is_breathing_now = is_breathing();
 876     uint8_t old_breath_speed = breath_speed;
 877
 878     if (is_breathing_now)
 879     {
 880         // Disable breathing interrupt
 881         TIMSK1 &= ~_BV(OCIE1A);
 882     }
 883
 884     breath_speed = value;
 885
 886     if (is_breathing_now)
 887     {
 888         // Adjust index to account for new speed
 889         breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
 890
 891         // Enable breathing interrupt
 892         TIMSK1 |= _BV(OCIE1A);
 893     }
 894
 895 }
 896
 897 void breathing_speed_inc(uint8_t value)
 898 {
 899     if ((uint16_t)(breath_speed - value) > 10 )
 900     {
 901         breathing_speed_set(0);
 902     }
 903     else
 904     {
 905         breathing_speed_set(breath_speed - value);
 906     }
 907 }
 908
 909 void breathing_speed_dec(uint8_t value)
 910 {
 911     if ((uint16_t)(breath_speed + value) > 10 )
 912     {
 913         breathing_speed_set(10);
 914     }
 915     else
 916     {
 917         breathing_speed_set(breath_speed + value);
 918     }
 919 }
 920
 921 void breathing_defaults(void)
 922 {
 923     breathing_intensity_default();
 924     breathing_speed_default();
 925     breathing_halt = BREATHING_NO_HALT;
 926 }
 927
 928 /* Breathing Sleep LED brighness(PWM On period) table
 929  * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
 930  *
 931  * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
 932  * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
 933  */
 934 static const uint8_t breathing_table[64] PROGMEM = {
 935   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   2,   4,   6,  10,
 936  15,  23,  32,  44,  58,  74,  93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
 937 255, 252, 245, 233, 218, 199, 179, 157, 135, 113,  93,  74,  58,  44,  32,  23,
 938  15,  10,   6,   4,   2,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 939 };
 940
 941 ISR(TIMER1_COMPA_vect)
 942 {
 943     // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
 944
 945
 946     uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
 947
 948     if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
 949     {
 950         // Disable breathing interrupt
 951         TIMSK1 &= ~_BV(OCIE1A);
 952     }
 953
 954     OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
 955
 956 }
 957
 958
 959
 960 #endif // breathing
 961
 962 #else // backlight
 963
 964 __attribute__ ((weak))
 965 void backlight_init_ports(void)
 966 {
 967
 968 }
 969
 970 __attribute__ ((weak))
 971 void backlight_set(uint8_t level)
 972 {
 973
 974 }
 975
 976 #endif // backlight
 977
 978
 979 // Functions for spitting out values
 980 //
 981
 982 void send_dword(uint32_t number) { // this might not actually work
 983     uint16_t word = (number >> 16);
 984     send_word(word);
 985     send_word(number & 0xFFFFUL);
 986 }
 987
 988 void send_word(uint16_t number) {
 989     uint8_t byte = number >> 8;
 990     send_byte(byte);
 991     send_byte(number & 0xFF);
 992 }
 993
 994 void send_byte(uint8_t number) {
 995     uint8_t nibble = number >> 4;
 996     send_nibble(nibble);
 997     send_nibble(number & 0xF);
 998 }
 999
1000 void send_nibble(uint8_t number) {
1001     switch (number) {
1002         case 0:
1003             register_code(KC_0);
1004             unregister_code(KC_0);
1005             break;
1006         case 1 ... 9:
1007             register_code(KC_1 + (number - 1));
1008             unregister_code(KC_1 + (number - 1));
1009             break;
1010         case 0xA ... 0xF:
1011             register_code(KC_A + (number - 0xA));
1012             unregister_code(KC_A + (number - 0xA));
1013             break;
1014     }
1015 }
1016
1017
1018 __attribute__((weak))
1019 uint16_t hex_to_keycode(uint8_t hex)
1020 {
1021   if (hex == 0x0) {
1022     return KC_0;
1023   } else if (hex < 0xA) {
1024     return KC_1 + (hex - 0x1);
1025   } else {
1026     return KC_A + (hex - 0xA);
1027   }
1028 }
1029
1030 void api_send_unicode(uint32_t unicode) {
1031 #ifdef API_ENABLE
1032     uint8_t chunk[4];
1033     dword_to_bytes(unicode, chunk);
1034     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1035 #endif
1036 }
1037
1038 __attribute__ ((weak))
1039 void led_set_user(uint8_t usb_led) {
1040
1041 }
1042
1043 __attribute__ ((weak))
1044 void led_set_kb(uint8_t usb_led) {
1045     led_set_user(usb_led);
1046 }
1047
1048 __attribute__ ((weak))
1049 void led_init_ports(void)
1050 {
1051
1052 }
1053
1054 __attribute__ ((weak))
1055 void led_set(uint8_t usb_led)
1056 {
1057
1058   // Example LED Code
1059   //
1060     // // Using PE6 Caps Lock LED
1061     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1062     // {
1063     //     // Output high.
1064     //     DDRE |= (1<<6);
1065     //     PORTE |= (1<<6);
1066     // }
1067     // else
1068     // {
1069     //     // Output low.
1070     //     DDRE &= ~(1<<6);
1071     //     PORTE &= ~(1<<6);
1072     // }
1073
1074   led_set_kb(usb_led);
1075 }
1076
1077
1078 //------------------------------------------------------------------------------
1079 // Override these functions in your keymap file to play different tunes on
1080 // different events such as startup and bootloader jump
1081
1082 __attribute__ ((weak))
1083 void startup_user() {}
1084
1085 __attribute__ ((weak))
1086 void shutdown_user() {}
1087
1088 //------------------------------------------------------------------------------