quantum/quantum.c

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