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