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