quantum/quantum.c

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