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