X-Git-Url: https://git.donarmstrong.com/?p=qmk_firmware.git;a=blobdiff_plain;f=quantum%2Fquantum.c;h=31dfa60cd61603a641aa4aaa4706eaffbdf8959f;hp=aac1d07a9b1e4b16f5b8e85fb76ef3e1e18f691b;hb=a5ecf146085716f3a79424c2f4b3b3039ff36b3e;hpb=1631f7cd798dcf428404977e441d7e5b65fe81ce diff --git a/quantum/quantum.c b/quantum/quantum.c index aac1d07a9..31dfa60cd 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -15,12 +15,17 @@ */ #include "quantum.h" + +#if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE) + #include "rgb.h" +#endif + #ifdef PROTOCOL_LUFA #include "outputselect.h" #endif -#ifndef TAPPING_TERM -#define TAPPING_TERM 200 +#ifndef BREATHING_PERIOD +#define BREATHING_PERIOD 6 #endif #include "backlight.h" @@ -30,6 +35,26 @@ extern backlight_config_t backlight_config; #include "fauxclicky.h" #endif +#ifdef API_ENABLE +#include "api.h" +#endif + +#ifdef MIDI_ENABLE +#include "process_midi.h" +#endif + +#ifdef VELOCIKEY_ENABLE +#include "velocikey.h" +#endif + +#ifdef HAPTIC_ENABLE + #include "haptic.h" +#endif + +#ifdef ENCODER_ENABLE +#include "encoder.h" +#endif + #ifdef AUDIO_ENABLE #ifndef GOODBYE_SONG #define GOODBYE_SONG SONG(GOODBYE_SOUND) @@ -115,6 +140,14 @@ void unregister_code16 (uint16_t code) { } } +void tap_code16(uint16_t code) { + register_code16(code); + #if TAP_CODE_DELAY > 0 + wait_ms(TAP_CODE_DELAY); + #endif + unregister_code16(code); +} + __attribute__ ((weak)) bool process_action_kb(keyrecord_t *record) { return true; @@ -132,56 +165,71 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { void reset_keyboard(void) { clear_keyboard(); -#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC)) - music_all_notes_off(); +#if defined(MIDI_ENABLE) && defined(MIDI_BASIC) + process_midi_all_notes_off(); +#endif +#ifdef AUDIO_ENABLE + #ifndef NO_MUSIC_MODE + music_all_notes_off(); + #endif uint16_t timer_start = timer_read(); PLAY_SONG(goodbye_song); shutdown_user(); - while(timer_elapsed(timer_start) < 250) + while(timer_elapsed(timer_start) < 250) wait_ms(1); stop_all_notes(); #else + shutdown_user(); wait_ms(250); #endif -#ifdef CATERINA_BOOTLOADER +#ifdef HAPTIC_ENABLE + haptic_shutdown(); +#endif +// this is also done later in bootloader.c - not sure if it's neccesary here +#ifdef BOOTLOADER_CATERINA *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific #endif bootloader_jump(); } -// Shift / paren setup - -#ifndef LSPO_KEY - #define LSPO_KEY KC_9 -#endif -#ifndef RSPC_KEY - #define RSPC_KEY KC_0 -#endif +/* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise. + * Used to ensure that the correct keycode is released if the key is released. + */ +static bool grave_esc_was_shifted = false; -static bool shift_interrupted[2] = {0, 0}; -static uint16_t scs_timer[2] = {0, 0}; +/* Convert record into usable keycode via the contained event. */ +uint16_t get_record_keycode(keyrecord_t *record) { + return get_event_keycode(record->event); +} -bool process_record_quantum(keyrecord_t *record) { - /* This gets the keycode from the key pressed */ - keypos_t key = record->event.key; - uint16_t keycode; +/* Convert event into usable keycode. Checks the layer cache to ensure that it + * retains the correct keycode after a layer change, if the key is still pressed. + */ +uint16_t get_event_keycode(keyevent_t event) { - #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) + #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE) /* TODO: Use store_or_get_action() or a similar function. */ if (!disable_action_cache) { uint8_t layer; - if (record->event.pressed) { - layer = layer_switch_get_layer(key); - update_source_layers_cache(key, layer); + if (event.pressed) { + layer = layer_switch_get_layer(event.key); + update_source_layers_cache(event.key, layer); } else { - layer = read_source_layers_cache(key); + layer = read_source_layers_cache(event.key); } - keycode = keymap_key_to_keycode(layer, key); + return keymap_key_to_keycode(layer, event.key); } else #endif - keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key); + return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key); +} + +/* Main keycode processing function. Hands off handling to other functions, + * then processes internal Quantum keycodes, then processes ACTIONs. + */ +bool process_record_quantum(keyrecord_t *record) { + uint16_t keycode = get_record_keycode(record); // This is how you use actions here // if (keycode == KC_LEAD) { @@ -191,10 +239,27 @@ bool process_record_quantum(keyrecord_t *record) { // return false; // } + #ifdef VELOCIKEY_ENABLE + if (velocikey_enabled() && record->event.pressed) { velocikey_accelerate(); } + #endif + + #ifdef TAP_DANCE_ENABLE + preprocess_tap_dance(keycode, record); + #endif + if (!( #if defined(KEY_LOCK_ENABLE) // Must run first to be able to mask key_up events. process_key_lock(&keycode, record) && + #endif + #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY) + process_clicky(keycode, record) && + #endif //AUDIO_CLICKY + #ifdef HAPTIC_ENABLE + process_haptic(keycode, record) && + #endif //HAPTIC_ENABLE + #if defined(RGB_MATRIX_ENABLE) + process_rgb_matrix(keycode, record) && #endif process_record_kb(keycode, record) && #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED) @@ -206,32 +271,32 @@ bool process_record_quantum(keyrecord_t *record) { #ifdef STENO_ENABLE process_steno(keycode, record) && #endif - #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC)) + #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE) process_music(keycode, record) && #endif #ifdef TAP_DANCE_ENABLE process_tap_dance(keycode, record) && #endif - #ifndef DISABLE_LEADER - process_leader(keycode, record) && + #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE) + process_unicode_common(keycode, record) && #endif - #ifndef DISABLE_CHORDING - process_chording(keycode, record) && + #ifdef LEADER_ENABLE + process_leader(keycode, record) && #endif #ifdef COMBO_ENABLE process_combo(keycode, record) && #endif - #ifdef UNICODE_ENABLE - process_unicode(keycode, record) && - #endif - #ifdef UCIS_ENABLE - process_ucis(keycode, record) && - #endif #ifdef PRINTING_ENABLE process_printer(keycode, record) && #endif - #ifdef UNICODEMAP_ENABLE - process_unicode_map(keycode, record) && + #ifdef AUTO_SHIFT_ENABLE + process_auto_shift(keycode, record) && + #endif + #ifdef TERMINAL_ENABLE + process_terminal(keycode, record) && + #endif + #ifdef SPACE_CADET_ENABLE + process_space_cadet(keycode, record) && #endif true)) { return false; @@ -244,105 +309,258 @@ bool process_record_quantum(keyrecord_t *record) { if (record->event.pressed) { reset_keyboard(); } - return false; - break; + return false; case DEBUG: if (record->event.pressed) { - print("\nDEBUG: enabled.\n"); - debug_enable = true; + debug_enable ^= 1; + if (debug_enable) { + print("DEBUG: enabled.\n"); + } else { + print("DEBUG: disabled.\n"); + } } - return false; - break; + return false; + case EEPROM_RESET: + if (record->event.pressed) { + eeconfig_init(); + } + return false; #ifdef FAUXCLICKY_ENABLE case FC_TOG: if (record->event.pressed) { FAUXCLICKY_TOGGLE; } return false; - break; case FC_ON: if (record->event.pressed) { FAUXCLICKY_ON; } return false; - break; case FC_OFF: if (record->event.pressed) { FAUXCLICKY_OFF; } return false; - break; #endif - #ifdef RGBLIGHT_ENABLE - case RGB_TOG: - if (record->event.pressed) { - rgblight_toggle(); + #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + case RGB_TOG: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_toggle(); + } + return false; + case RGB_MODE_FORWARD: + if (record->event.pressed) { + uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)); + if(shifted) { + rgblight_step_reverse(); } - return false; - break; - case RGB_MOD: - if (record->event.pressed) { - rgblight_step(); + else { + rgblight_step(); } - return false; - break; - case RGB_HUI: - if (record->event.pressed) { - rgblight_increase_hue(); + } + return false; + case RGB_MODE_REVERSE: + if (record->event.pressed) { + uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)); + if(shifted) { + rgblight_step(); } - return false; - break; - case RGB_HUD: - if (record->event.pressed) { - rgblight_decrease_hue(); + else { + rgblight_step_reverse(); } - return false; - break; - case RGB_SAI: - if (record->event.pressed) { - rgblight_increase_sat(); + } + return false; + case RGB_HUI: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_increase_hue(); + } + return false; + case RGB_HUD: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_decrease_hue(); + } + return false; + case RGB_SAI: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_increase_sat(); + } + return false; + case RGB_SAD: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_decrease_sat(); + } + return false; + case RGB_VAI: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_increase_val(); + } + return false; + case RGB_VAD: + // Split keyboards need to trigger on key-up for edge-case issue + #ifndef SPLIT_KEYBOARD + if (record->event.pressed) { + #else + if (!record->event.pressed) { + #endif + rgblight_decrease_val(); + } + return false; + case RGB_SPI: + if (record->event.pressed) { + rgblight_increase_speed(); + } + return false; + case RGB_SPD: + if (record->event.pressed) { + rgblight_decrease_speed(); + } + return false; + case RGB_MODE_PLAIN: + if (record->event.pressed) { + rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT); + } + return false; + case RGB_MODE_BREATHE: + #ifdef RGBLIGHT_EFFECT_BREATHING + if (record->event.pressed) { + if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) && + (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) { + rgblight_step(); + } else { + rgblight_mode(RGBLIGHT_MODE_BREATHING); } - return false; - break; - case RGB_SAD: - if (record->event.pressed) { - rgblight_decrease_sat(); + } + #endif + return false; + case RGB_MODE_RAINBOW: + #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD + if (record->event.pressed) { + if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) && + (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) { + rgblight_step(); + } else { + rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD); } - return false; - break; - case RGB_VAI: - if (record->event.pressed) { - rgblight_increase_val(); + } + #endif + return false; + case RGB_MODE_SWIRL: + #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL + if (record->event.pressed) { + if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) && + (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) { + rgblight_step(); + } else { + rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL); } - return false; - break; - case RGB_VAD: - if (record->event.pressed) { - rgblight_decrease_val(); + } + #endif + return false; + case RGB_MODE_SNAKE: + #ifdef RGBLIGHT_EFFECT_SNAKE + if (record->event.pressed) { + if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) && + (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) { + rgblight_step(); + } else { + rgblight_mode(RGBLIGHT_MODE_SNAKE); } - return false; - break; - #endif - #ifdef PROTOCOL_LUFA + } + #endif + return false; + case RGB_MODE_KNIGHT: + #ifdef RGBLIGHT_EFFECT_KNIGHT + if (record->event.pressed) { + if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) && + (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) { + rgblight_step(); + } else { + rgblight_mode(RGBLIGHT_MODE_KNIGHT); + } + } + #endif + return false; + case RGB_MODE_XMAS: + #ifdef RGBLIGHT_EFFECT_CHRISTMAS + if (record->event.pressed) { + rgblight_mode(RGBLIGHT_MODE_CHRISTMAS); + } + #endif + return false; + case RGB_MODE_GRADIENT: + #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT + if (record->event.pressed) { + if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) && + (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) { + rgblight_step(); + } else { + rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT); + } + } + #endif + return false; + case RGB_MODE_RGBTEST: + #ifdef RGBLIGHT_EFFECT_RGB_TEST + if (record->event.pressed) { + rgblight_mode(RGBLIGHT_MODE_RGB_TEST); + } + #endif + return false; + #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) + #ifdef VELOCIKEY_ENABLE + case VLK_TOG: + if (record->event.pressed) { + velocikey_toggle(); + } + return false; + #endif + #ifdef PROTOCOL_LUFA case OUT_AUTO: if (record->event.pressed) { set_output(OUTPUT_AUTO); } return false; - break; case OUT_USB: if (record->event.pressed) { set_output(OUTPUT_USB); } return false; - break; #ifdef BLUETOOTH_ENABLE case OUT_BT: if (record->event.pressed) { set_output(OUTPUT_BLUETOOTH); } return false; - break; #endif #endif case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO: @@ -417,6 +635,17 @@ bool process_record_quantum(keyrecord_t *record) { PLAY_SONG(ag_norm_song); #endif break; + case MAGIC_TOGGLE_ALT_GUI: + keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui; + keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui; + #ifdef AUDIO_ENABLE + if (keymap_config.swap_ralt_rgui) { + PLAY_SONG(ag_swap_song); + } else { + PLAY_SONG(ag_norm_song); + } + #endif + break; case MAGIC_TOGGLE_NKRO: keymap_config.nkro = !keymap_config.nkro; break; @@ -429,82 +658,73 @@ bool process_record_quantum(keyrecord_t *record) { return false; } break; - case KC_LSPO: { + + case GRAVE_ESC: { + uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT) + |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))); + +#ifdef GRAVE_ESC_ALT_OVERRIDE + // if ALT is pressed, ESC is always sent + // this is handy for the cmd+opt+esc shortcut on macOS, among other things. + if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) { + shifted = 0; + } +#endif + +#ifdef GRAVE_ESC_CTRL_OVERRIDE + // if CTRL is pressed, ESC is always sent + // this is handy for the ctrl+shift+esc shortcut on windows, among other things. + if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) { + shifted = 0; + } +#endif + +#ifdef GRAVE_ESC_GUI_OVERRIDE + // if GUI is pressed, ESC is always sent + if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) { + shifted = 0; + } +#endif + +#ifdef GRAVE_ESC_SHIFT_OVERRIDE + // if SHIFT is pressed, ESC is always sent + if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) { + shifted = 0; + } +#endif + if (record->event.pressed) { - shift_interrupted[0] = false; - scs_timer[0] = timer_read (); - register_mods(MOD_BIT(KC_LSFT)); + grave_esc_was_shifted = shifted; + add_key(shifted ? KC_GRAVE : KC_ESCAPE); } else { - #ifdef DISABLE_SPACE_CADET_ROLLOVER - if (get_mods() & MOD_BIT(KC_RSFT)) { - shift_interrupted[0] = true; - shift_interrupted[1] = true; - } - #endif - if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) { - register_code(LSPO_KEY); - unregister_code(LSPO_KEY); - } - unregister_mods(MOD_BIT(KC_LSFT)); + del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE); } + + send_keyboard_report(); return false; - // break; } - case KC_RSPC: { +#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING) + case BL_BRTG: { if (record->event.pressed) { - shift_interrupted[1] = false; - scs_timer[1] = timer_read (); - register_mods(MOD_BIT(KC_RSFT)); - } - else { - #ifdef DISABLE_SPACE_CADET_ROLLOVER - if (get_mods() & MOD_BIT(KC_LSFT)) { - shift_interrupted[0] = true; - shift_interrupted[1] = true; - } - #endif - if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) { - register_code(RSPC_KEY); - unregister_code(RSPC_KEY); - } - unregister_mods(MOD_BIT(KC_RSFT)); + breathing_toggle(); } return false; - // break; } - case GRAVE_ESC: { - void (*method)(uint8_t) = (record->event.pressed) ? &add_key : &del_key; - uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT) - |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))); - -#ifdef GRAVE_ESC_CTRL_OVERRIDE - // if CTRL is pressed, ESC is always read as ESC, even if SHIFT or GUI is pressed. - // this is handy for the ctrl+shift+esc shortcut on windows, among other things. - if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) - shifted = 0; #endif - - method(shifted ? KC_GRAVE : KC_ESCAPE); - send_keyboard_report(); - } - default: { - shift_interrupted[0] = true; - shift_interrupted[1] = true; - break; - } } return process_action_kb(record); } __attribute__ ((weak)) -const bool ascii_to_shift_lut[0x80] PROGMEM = { +const bool ascii_to_shift_lut[128] PROGMEM = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -520,44 +740,116 @@ const bool ascii_to_shift_lut[0x80] PROGMEM = { }; __attribute__ ((weak)) -const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = { +const bool ascii_to_altgr_lut[128] PROGMEM = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, KC_ESC, 0, 0, 0, 0, - KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT, - KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH, - KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, - KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH, - KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, - KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, - KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W, - KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS, - KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, - KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, - KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W, - KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 +}; + +__attribute__ ((weak)) +const uint8_t ascii_to_keycode_lut[128] PROGMEM = { + // NUL SOH STX ETX EOT ENQ ACK BEL + XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, + // BS TAB LF VT FF CR SO SI + KC_BSPC, KC_TAB, KC_ENT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, + // DLE DC1 DC2 DC3 DC4 NAK SYN ETB + XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, + // CAN EM SUB ESC FS GS RS US + XXXXXXX, XXXXXXX, XXXXXXX, KC_ESC, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, + + // ! " # $ % & ' + KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT, + // ( ) * + , - . / + KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH, + // 0 1 2 3 4 5 6 7 + KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, + // 8 9 : ; < = > ? + KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH, + // @ A B C D E F G + KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, + // H I J K L M N O + KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, + // P Q R S T U V W + KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W, + // X Y Z [ \ ] ^ _ + KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS, + // ` a b c d e f g + KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, + // h i j k l m n o + KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, + // p q r s t u v w + KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W, + // x y z { | } ~ DEL + KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL }; void send_string(const char *str) { send_string_with_delay(str, 0); } +void send_string_P(const char *str) { + send_string_with_delay_P(str, 0); +} + void send_string_with_delay(const char *str, uint8_t interval) { while (1) { - uint8_t keycode; - uint8_t ascii_code = pgm_read_byte(str); + char ascii_code = *str; if (!ascii_code) break; - keycode = pgm_read_byte(&ascii_to_keycode_lut[ascii_code]); - if (pgm_read_byte(&ascii_to_shift_lut[ascii_code])) { - register_code(KC_LSFT); - register_code(keycode); - unregister_code(keycode); - unregister_code(KC_LSFT); + if (ascii_code == SS_TAP_CODE) { + // tap + uint8_t keycode = *(++str); + register_code(keycode); + unregister_code(keycode); + } else if (ascii_code == SS_DOWN_CODE) { + // down + uint8_t keycode = *(++str); + register_code(keycode); + } else if (ascii_code == SS_UP_CODE) { + // up + uint8_t keycode = *(++str); + unregister_code(keycode); + } else { + send_char(ascii_code); } - else { - register_code(keycode); - unregister_code(keycode); + ++str; + // interval + { uint8_t ms = interval; while (ms--) wait_ms(1); } + } +} + +void send_string_with_delay_P(const char *str, uint8_t interval) { + while (1) { + char ascii_code = pgm_read_byte(str); + if (!ascii_code) break; + if (ascii_code == SS_TAP_CODE) { + // tap + uint8_t keycode = pgm_read_byte(++str); + register_code(keycode); + unregister_code(keycode); + } else if (ascii_code == SS_DOWN_CODE) { + // down + uint8_t keycode = pgm_read_byte(++str); + register_code(keycode); + } else if (ascii_code == SS_UP_CODE) { + // up + uint8_t keycode = pgm_read_byte(++str); + unregister_code(keycode); + } else { + send_char(ascii_code); } ++str; // interval @@ -565,6 +857,26 @@ void send_string_with_delay(const char *str, uint8_t interval) { } } +void send_char(char ascii_code) { + uint8_t keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]); + bool is_shifted = pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code]); + bool is_altgred = pgm_read_byte(&ascii_to_altgr_lut[(uint8_t)ascii_code]); + + if (is_shifted) { + register_code(KC_LSFT); + } + if (is_altgred) { + register_code(KC_RALT); + } + tap_code(keycode); + if (is_altgred) { + unregister_code(KC_RALT); + } + if (is_shifted) { + unregister_code(KC_LSFT); + } +} + void set_single_persistent_default_layer(uint8_t default_layer) { #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS) PLAY_SONG(default_layer_songs[default_layer]); @@ -573,12 +885,14 @@ void set_single_persistent_default_layer(uint8_t default_layer) { default_layer_set(1U< 0 + wait_ms(DEBOUNCING_DELAY * 2); + #elif defined(DEBOUNCE) && DEBOUNCE > 0 + wait_ms(DEBOUNCE * 2); + #else + wait_ms(30); + #endif + matrix_scan(); + + // If the Esc and space bar are held down on power up, + // reset the EEPROM valid state and jump to bootloader. + // Assumes Esc is at [0,0]. + // This isn't very generalized, but we need something that doesn't + // rely on user's keymaps in firmware or EEPROM. + if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) { + eeconfig_disable(); + // Jump to bootloader. + bootloader_jump(); + } +} + void matrix_init_quantum() { + #ifdef BOOTMAGIC_LITE + bootmagic_lite(); + #endif + if (!eeconfig_is_enabled()) { + eeconfig_init(); + } #ifdef BACKLIGHT_ENABLE - backlight_init_ports(); + #ifdef LED_MATRIX_ENABLE + led_matrix_init(); + #else + backlight_init_ports(); + #endif #endif #ifdef AUDIO_ENABLE audio_init(); #endif + #ifdef RGB_MATRIX_ENABLE + rgb_matrix_init(); + #endif + #ifdef ENCODER_ENABLE + encoder_init(); + #endif + #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE) + unicode_input_mode_init(); + #endif + #ifdef HAPTIC_ENABLE + haptic_init(); + #endif + #ifdef OUTPUT_AUTO_ENABLE + set_output(OUTPUT_AUTO); + #endif matrix_init_kb(); } void matrix_scan_quantum() { - #ifdef AUDIO_ENABLE + #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE) matrix_scan_music(); #endif @@ -642,366 +1010,516 @@ void matrix_scan_quantum() { matrix_scan_combo(); #endif - #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN) - backlight_task(); + #if defined(BACKLIGHT_ENABLE) + #if defined(LED_MATRIX_ENABLE) + led_matrix_task(); + #elif defined(BACKLIGHT_PIN) + backlight_task(); + #endif + #endif + + #ifdef RGB_MATRIX_ENABLE + rgb_matrix_task(); + #endif + + #ifdef ENCODER_ENABLE + encoder_read(); + #endif + + #ifdef HAPTIC_ENABLE + haptic_task(); #endif matrix_scan_kb(); } +#if defined(BACKLIGHT_ENABLE) && (defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)) -#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN) - -static const uint8_t backlight_pin = BACKLIGHT_PIN; +// The logic is a bit complex, we support 3 setups: +// 1. hardware PWM when backlight is wired to a PWM pin +// depending on this pin, we use a different output compare unit +// 2. software PWM with hardware timers, but the used timer depends +// on the audio setup (audio wins other backlight) +// 3. full software PWM #if BACKLIGHT_PIN == B7 -# define COM1x1 COM1C1 -# define OCR1x OCR1C +# define HARDWARE_PWM +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define COMxx1 COM1C1 +# define OCRxx OCR1C +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 +# define ICRx ICR1 +# define TIMSKx TIMSK1 #elif BACKLIGHT_PIN == B6 -# define COM1x1 COM1B1 -# define OCR1x OCR1B +# define HARDWARE_PWM +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 +# define ICRx ICR1 +# define TIMSKx TIMSK1 #elif BACKLIGHT_PIN == B5 -# define COM1x1 COM1A1 -# define OCR1x OCR1A +# define HARDWARE_PWM +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define COMxx1 COM1A1 +# define OCRxx OCR1A +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 +# define ICRx ICR1 +# define TIMSKx TIMSK1 +#elif BACKLIGHT_PIN == C6 +# define HARDWARE_PWM +# define TCCRxA TCCR3A +# define TCCRxB TCCR3B +# define COMxx1 COM3A1 +# define OCRxx OCR3A +# define TIMERx_OVF_vect TIMER3_OVF_vect +# define TOIEx TOIE3 +# define ICRx ICR3 +# define TIMSKx TIMSK3 +#elif defined(__AVR_ATmega32A__) && BACKLIGHT_PIN == D4 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 +# define ICRx ICR1 +# define TIMSKx TIMSK1 #else -# define NO_BACKLIGHT_CLOCK +# if !defined(BACKLIGHT_CUSTOM_DRIVER) +# if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) + // timer 1 is not used by audio , backlight can use it +#pragma message "Using hardware timer 1 with software PWM" +# define HARDWARE_PWM +# define BACKLIGHT_PWM_TIMER +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define OCRxx OCR1A +# define TIMERx_COMPA_vect TIMER1_COMPA_vect +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define OCIExA OCIE1A +# define TOIEx TOIE1 +# define ICRx ICR1 +# if defined(__AVR_ATmega32A__) // This MCU has only one TIMSK register +# define TIMSKx TIMSK +# else +# define TIMSKx TIMSK1 +# endif +# elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO) +#pragma message "Using hardware timer 3 with software PWM" +// timer 3 is not used by audio, backlight can use it +# define HARDWARE_PWM +# define BACKLIGHT_PWM_TIMER +# define TCCRxA TCCR3A +# define TCCRxB TCCR3B +# define OCRxx OCR3A +# define TIMERx_COMPA_vect TIMER3_COMPA_vect +# define TIMERx_OVF_vect TIMER3_OVF_vect +# define OCIExA OCIE3A +# define TOIEx TOIE3 +# define ICRx ICR1 +# define TIMSKx TIMSK3 +# else +#pragma message "Audio in use - using pure software PWM" +#define NO_HARDWARE_PWM +# endif +# else +#pragma message "Custom driver defined - using pure software PWM" +#define NO_HARDWARE_PWM +# endif #endif #ifndef BACKLIGHT_ON_STATE #define BACKLIGHT_ON_STATE 0 #endif -__attribute__ ((weak)) +void backlight_on(uint8_t backlight_pin) { +#if BACKLIGHT_ON_STATE == 0 + writePinLow(backlight_pin); +#else + writePinHigh(backlight_pin); +#endif +} + +void backlight_off(uint8_t backlight_pin) { +#if BACKLIGHT_ON_STATE == 0 + writePinHigh(backlight_pin); +#else + writePinLow(backlight_pin); +#endif +} + + +#if defined(NO_HARDWARE_PWM) || defined(BACKLIGHT_PWM_TIMER) // pwm through software + +// we support multiple backlight pins +#ifndef BACKLIGHT_LED_COUNT +#define BACKLIGHT_LED_COUNT 1 +#endif + +#if BACKLIGHT_LED_COUNT == 1 +#define BACKLIGHT_PIN_INIT { BACKLIGHT_PIN } +#else +#define BACKLIGHT_PIN_INIT BACKLIGHT_PINS +#endif + +#define FOR_EACH_LED(x) \ + for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) \ + { \ + uint8_t backlight_pin = backlight_pins[i]; \ + { \ + x \ + } \ + } + +static const uint8_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT; + +#else // full hardware PWM + +// we support only one backlight pin +static const uint8_t backlight_pin = BACKLIGHT_PIN; +#define FOR_EACH_LED(x) x + +#endif + +#ifdef NO_HARDWARE_PWM +__attribute__((weak)) void backlight_init_ports(void) { - // Setup backlight pin as output and output to on state. - // DDRx |= n - _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF); - #if BACKLIGHT_ON_STATE == 0 - // PORTx &= ~n - _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); - #else - // PORTx |= n - _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); - #endif + FOR_EACH_LED( + setPinOutput(backlight_pin); + backlight_on(backlight_pin); + ) +} - #ifndef NO_BACKLIGHT_CLOCK - // Use full 16-bit resolution. - ICR1 = 0xFFFF; +__attribute__ ((weak)) +void backlight_set(uint8_t level) {} - // I could write a wall of text here to explain... but TL;DW - // Go read the ATmega32u4 datasheet. - // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on +uint8_t backlight_tick = 0; - // Pin PB7 = OCR1C (Timer 1, Channel C) - // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0 - // (i.e. start high, go low when counter matches.) - // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0 - // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1 +#ifndef BACKLIGHT_CUSTOM_DRIVER +void backlight_task(void) { + if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) { + FOR_EACH_LED( + backlight_on(backlight_pin); + ) + } + else { + FOR_EACH_LED( + backlight_off(backlight_pin); + ) + } + backlight_tick = (backlight_tick + 1) % 16; +} +#endif - TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010; - TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; +#ifdef BACKLIGHT_BREATHING + #ifndef BACKLIGHT_CUSTOM_DRIVER + #error "Backlight breathing only available with hardware PWM. Please disable." #endif +#endif - backlight_init(); - #ifdef BACKLIGHT_BREATHING - breathing_defaults(); - #endif +#else // hardware pwm through timer + +#ifdef BACKLIGHT_PWM_TIMER + +// The idea of software PWM assisted by hardware timers is the following +// we use the hardware timer in fast PWM mode like for hardware PWM, but +// instead of letting the Output Match Comparator control the led pin +// (which is not possible since the backlight is not wired to PWM pins on the +// CPU), we do the LED on/off by oursleves. +// The timer is setup to count up to 0xFFFF, and we set the Output Compare +// register to the current 16bits backlight level (after CIE correction). +// This means the CPU will trigger a compare match interrupt when the counter +// reaches the backlight level, where we turn off the LEDs, +// but also an overflow interrupt when the counter rolls back to 0, +// in which we're going to turn on the LEDs. +// The LED will then be on for OCRxx/0xFFFF time, adjusted every 244Hz. + +// Triggered when the counter reaches the OCRx value +ISR(TIMERx_COMPA_vect) { + FOR_EACH_LED( + backlight_off(backlight_pin); + ) } -__attribute__ ((weak)) -void backlight_set(uint8_t level) -{ - // Prevent backlight blink on lowest level - // #if BACKLIGHT_ON_STATE == 0 - // // PORTx &= ~n - // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); - // #else - // // PORTx |= n - // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); - // #endif - - if ( level == 0 ) { - #ifndef NO_BACKLIGHT_CLOCK - // Turn off PWM control on backlight pin, revert to output low. - TCCR1A &= ~(_BV(COM1x1)); - OCR1x = 0x0; - #else - // #if BACKLIGHT_ON_STATE == 0 - // // PORTx |= n - // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); - // #else - // // PORTx &= ~n - // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); - // #endif - #endif +// Triggered when the counter reaches the TOP value +// this one triggers at F_CPU/65536 =~ 244 Hz +ISR(TIMERx_OVF_vect) { +#ifdef BACKLIGHT_BREATHING + if(is_breathing()) { + breathing_task(); } - #ifndef NO_BACKLIGHT_CLOCK - else if ( level == BACKLIGHT_LEVELS ) { - // Turn on PWM control of backlight pin - TCCR1A |= _BV(COM1x1); - // Set the brightness - OCR1x = 0xFFFF; - } - else { - // Turn on PWM control of backlight pin - TCCR1A |= _BV(COM1x1); - // Set the brightness - OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2)); - } - #endif +#endif + // for very small values of OCRxx (or backlight level) + // we can't guarantee this whole code won't execute + // at the same time as the compare match interrupt + // which means that we might turn on the leds while + // trying to turn them off, leading to flickering + // artifacts (especially while breathing, because breathing_task + // takes many computation cycles). + // so better not turn them on while the counter TOP is very low. + if (OCRxx > 256) { + FOR_EACH_LED( + backlight_on(backlight_pin); + ) + } +} - #ifdef BACKLIGHT_BREATHING - breathing_intensity_default(); - #endif +#endif + +#define TIMER_TOP 0xFFFFU + +// See http://jared.geek.nz/2013/feb/linear-led-pwm +static uint16_t cie_lightness(uint16_t v) { + if (v <= 5243) // if below 8% of max + return v / 9; // same as dividing by 900% + else { + uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare + // to get a useful result with integer division, we shift left in the expression above + // and revert what we've done again after squaring. + y = y * y * y >> 8; + if (y > 0xFFFFUL) // prevent overflow + return 0xFFFFU; + else + return (uint16_t) y; + } } -uint8_t backlight_tick = 0; +// range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val. +static inline void set_pwm(uint16_t val) { + OCRxx = val; +} -void backlight_task(void) { - #ifdef NO_BACKLIGHT_CLOCK - if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) { - #if BACKLIGHT_ON_STATE == 0 - // PORTx &= ~n - _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); +#ifndef BACKLIGHT_CUSTOM_DRIVER +__attribute__ ((weak)) +void backlight_set(uint8_t level) { + if (level > BACKLIGHT_LEVELS) + level = BACKLIGHT_LEVELS; + + if (level == 0) { + #ifdef BACKLIGHT_PWM_TIMER + if (OCRxx) { + TIMSKx &= ~(_BV(OCIExA)); + TIMSKx &= ~(_BV(TOIEx)); + FOR_EACH_LED( + backlight_off(backlight_pin); + ) + } #else - // PORTx |= n - _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); + // Turn off PWM control on backlight pin + TCCRxA &= ~(_BV(COMxx1)); #endif } else { - #if BACKLIGHT_ON_STATE == 0 - // PORTx |= n - _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); + #ifdef BACKLIGHT_PWM_TIMER + if (!OCRxx) { + TIMSKx |= _BV(OCIExA); + TIMSKx |= _BV(TOIEx); + } #else - // PORTx &= ~n - _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); + // Turn on PWM control of backlight pin + TCCRxA |= _BV(COMxx1); #endif } - backlight_tick = (backlight_tick + 1) % 16; - #endif + // Set the brightness + set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS)); } +void backlight_task(void) {} +#endif // BACKLIGHT_CUSTOM_DRIVER + #ifdef BACKLIGHT_BREATHING #define BREATHING_NO_HALT 0 #define BREATHING_HALT_OFF 1 #define BREATHING_HALT_ON 2 +#define BREATHING_STEPS 128 -static uint8_t breath_intensity; -static uint8_t breath_speed; -static uint16_t breathing_index; -static uint8_t breathing_halt; +static uint8_t breathing_period = BREATHING_PERIOD; +static uint8_t breathing_halt = BREATHING_NO_HALT; +static uint16_t breathing_counter = 0; -void breathing_enable(void) -{ - if (get_backlight_level() == 0) - { - breathing_index = 0; - } - else - { - // Set breathing_index to be at the midpoint (brightest point) - breathing_index = 0x20 << breath_speed; - } - - breathing_halt = BREATHING_NO_HALT; +#ifdef BACKLIGHT_PWM_TIMER +static bool breathing = false; - // Enable breathing interrupt - TIMSK1 |= _BV(OCIE1A); +bool is_breathing(void) { + return breathing; } -void breathing_pulse(void) -{ - if (get_backlight_level() == 0) - { - breathing_index = 0; - } - else - { - // Set breathing_index to be at the midpoint + 1 (brightest point) - breathing_index = 0x21 << breath_speed; - } - - breathing_halt = BREATHING_HALT_ON; +#define breathing_interrupt_enable() do { breathing = true; } while (0) +#define breathing_interrupt_disable() do { breathing = false; } while (0) +#else - // Enable breathing interrupt - TIMSK1 |= _BV(OCIE1A); +bool is_breathing(void) { + return !!(TIMSKx & _BV(TOIEx)); } -void breathing_disable(void) +#define breathing_interrupt_enable() do {TIMSKx |= _BV(TOIEx);} while (0) +#define breathing_interrupt_disable() do {TIMSKx &= ~_BV(TOIEx);} while (0) +#endif + +#define breathing_min() do {breathing_counter = 0;} while (0) +#define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0) + +void breathing_enable(void) { - // Disable breathing interrupt - TIMSK1 &= ~_BV(OCIE1A); - backlight_set(get_backlight_level()); + breathing_counter = 0; + breathing_halt = BREATHING_NO_HALT; + breathing_interrupt_enable(); } -void breathing_self_disable(void) +void breathing_pulse(void) { if (get_backlight_level() == 0) - { - breathing_halt = BREATHING_HALT_OFF; - } + breathing_min(); else - { - breathing_halt = BREATHING_HALT_ON; - } - - //backlight_set(get_backlight_level()); + breathing_max(); + breathing_halt = BREATHING_HALT_ON; + breathing_interrupt_enable(); } -void breathing_toggle(void) +void breathing_disable(void) { - if (!is_breathing()) - { - if (get_backlight_level() == 0) - { - breathing_index = 0; - } - else - { - // Set breathing_index to be at the midpoint + 1 (brightest point) - breathing_index = 0x21 << breath_speed; - } - - breathing_halt = BREATHING_NO_HALT; - } - - // Toggle breathing interrupt - TIMSK1 ^= _BV(OCIE1A); - + breathing_interrupt_disable(); // Restore backlight level - if (!is_breathing()) - { - backlight_set(get_backlight_level()); - } + backlight_set(get_backlight_level()); } -bool is_breathing(void) +void breathing_self_disable(void) { - return (TIMSK1 && _BV(OCIE1A)); + if (get_backlight_level() == 0) + breathing_halt = BREATHING_HALT_OFF; + else + breathing_halt = BREATHING_HALT_ON; } -void breathing_intensity_default(void) -{ - //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS); - breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2)); +void breathing_toggle(void) { + if (is_breathing()) + breathing_disable(); + else + breathing_enable(); } -void breathing_intensity_set(uint8_t value) +void breathing_period_set(uint8_t value) { - breath_intensity = value; + if (!value) + value = 1; + breathing_period = value; } -void breathing_speed_default(void) -{ - breath_speed = 4; +void breathing_period_default(void) { + breathing_period_set(BREATHING_PERIOD); } -void breathing_speed_set(uint8_t value) +void breathing_period_inc(void) { - bool is_breathing_now = is_breathing(); - uint8_t old_breath_speed = breath_speed; - - if (is_breathing_now) - { - // Disable breathing interrupt - TIMSK1 &= ~_BV(OCIE1A); - } - - breath_speed = value; - - if (is_breathing_now) - { - // Adjust index to account for new speed - breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed; - - // Enable breathing interrupt - TIMSK1 |= _BV(OCIE1A); - } - + breathing_period_set(breathing_period+1); } -void breathing_speed_inc(uint8_t value) +void breathing_period_dec(void) { - if ((uint16_t)(breath_speed - value) > 10 ) - { - breathing_speed_set(0); - } - else - { - breathing_speed_set(breath_speed - value); - } + breathing_period_set(breathing_period-1); } -void breathing_speed_dec(uint8_t value) -{ - if ((uint16_t)(breath_speed + value) > 10 ) - { - breathing_speed_set(10); - } - else - { - breathing_speed_set(breath_speed + value); - } -} +/* To generate breathing curve in python: + * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)] + */ +static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; -void breathing_defaults(void) -{ - breathing_intensity_default(); - breathing_speed_default(); - breathing_halt = BREATHING_NO_HALT; +// Use this before the cie_lightness function. +static inline uint16_t scale_backlight(uint16_t v) { + return v / BACKLIGHT_LEVELS * get_backlight_level(); } -/* Breathing Sleep LED brighness(PWM On period) table - * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle - * - * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63 - * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i } +#ifdef BACKLIGHT_PWM_TIMER +void breathing_task(void) +#else +/* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run + * about 244 times per second. */ -static const uint8_t breathing_table[64] PROGMEM = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10, - 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252, -255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23, - 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; - -ISR(TIMER1_COMPA_vect) +ISR(TIMERx_OVF_vect) +#endif { - // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity; - - - uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F; - - if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F))) - { - // Disable breathing interrupt - TIMSK1 &= ~_BV(OCIE1A); - } - - OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity; + uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS; + // resetting after one period to prevent ugly reset at overflow. + breathing_counter = (breathing_counter + 1) % (breathing_period * 244); + uint8_t index = breathing_counter / interval % BREATHING_STEPS; + + if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) || + ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1))) + { + breathing_interrupt_disable(); + } + set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U))); } - - -#endif // breathing - -#else // backlight +#endif // BACKLIGHT_BREATHING __attribute__ ((weak)) void backlight_init_ports(void) { + // Setup backlight pin as output and output to on state. + FOR_EACH_LED( + setPinOutput(backlight_pin); + backlight_on(backlight_pin); + ) + + // I could write a wall of text here to explain... but TL;DW + // Go read the ATmega32u4 datasheet. + // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on + +#ifdef BACKLIGHT_PWM_TIMER + // TimerX setup, Fast PWM mode count to TOP set in ICRx + TCCRxA = _BV(WGM11); // = 0b00000010; + // clock select clk/1 + TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; +#else // hardware PWM + // Pin PB7 = OCR1C (Timer 1, Channel C) + // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0 + // (i.e. start high, go low when counter matches.) + // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0 + // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1 + + /* + 14.8.3: + "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]." + "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)." + */ + TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010; + TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; +#endif + // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0. + ICRx = TIMER_TOP; + backlight_init(); + #ifdef BACKLIGHT_BREATHING + breathing_enable(); + #endif } +#endif // hardware backlight + +#else // no backlight + __attribute__ ((weak)) -void backlight_set(uint8_t level) -{ +void backlight_init_ports(void) {} -} +__attribute__ ((weak)) +void backlight_set(uint8_t level) {} #endif // backlight +#ifdef HD44780_ENABLED +#include "hd44780.h" +#endif + // Functions for spitting out values // @@ -1045,6 +1563,7 @@ void send_nibble(uint8_t number) { __attribute__((weak)) uint16_t hex_to_keycode(uint8_t hex) { + hex = hex & 0xF; if (hex == 0x0) { return KC_0; } else if (hex < 0xA) { @@ -1081,22 +1600,23 @@ void led_init_ports(void) __attribute__ ((weak)) void led_set(uint8_t usb_led) { +#if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE) + // Use backlight as Caps Lock indicator + uint8_t bl_toggle_lvl = 0; + + if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) { + // Turning Caps Lock ON and backlight is disabled in config + // Toggling backlight to the brightest level + bl_toggle_lvl = BACKLIGHT_LEVELS; + } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) { + // Turning Caps Lock OFF and backlight is enabled in config + // Toggling backlight and restoring config level + bl_toggle_lvl = backlight_config.level; + } - // Example LED Code - // - // // Using PE6 Caps Lock LED - // if (usb_led & (1<