quantum/quantum.c

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