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