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