quantum/quantum.c

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