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