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