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