quantum/quantum.c

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