*/
#include "quantum.h"
-#ifdef PROTOCOL_LUFA
-#include "outputselect.h"
+
+#if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE)
+ #include "rgb.h"
#endif
-#ifndef TAPPING_TERM
-#define TAPPING_TERM 200
+#ifdef PROTOCOL_LUFA
+#include "outputselect.h"
#endif
#ifndef BREATHING_PERIOD
#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)
}
}
+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;
#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
process_midi_all_notes_off();
#endif
-#if defined(AUDIO_ENABLE)
- music_all_notes_off();
+#ifdef AUDIO_ENABLE
+ #ifndef NO_MUSIC_MODE
+ music_all_notes_off();
+ #endif
uint16_t timer_start = timer_read();
PLAY_SONG(goodbye_song);
shutdown_user();
wait_ms(1);
stop_all_notes();
#else
+ shutdown_user();
wait_ms(250);
#endif
+#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
bootloader_jump();
}
-// Shift / paren setup
-
-#ifndef LSPO_KEY
- #define LSPO_KEY KC_9
-#endif
-#ifndef RSPC_KEY
- #define RSPC_KEY KC_0
-#endif
-
-// Shift / Enter setup
-#ifndef SFTENT_KEY
- #define SFTENT_KEY KC_ENT
-#endif
-
-static bool shift_interrupted[2] = {0, 0};
-static uint16_t scs_timer[2] = {0, 0};
-
/* 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;
-bool process_record_quantum(keyrecord_t *record) {
+/* Convert record into usable keycode via the contained event. */
+uint16_t get_record_keycode(keyrecord_t *record) {
+ return get_event_keycode(record->event);
+}
+
- /* 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) {
// 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)
#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 AUTO_SHIFT_ENABLE
process_auto_shift(keycode, record) &&
#endif
- #ifdef UNICODEMAP_ENABLE
- process_unicode_map(keycode, record) &&
- #endif
#ifdef TERMINAL_ENABLE
process_terminal(keycode, record) &&
+ #endif
+ #ifdef SPACE_CADET_ENABLE
+ process_space_cadet(keycode, record) &&
#endif
true)) {
return false;
return false;
case DEBUG:
if (record->event.pressed) {
- debug_enable = true;
+ debug_enable ^= 1;
+ if (debug_enable) {
print("DEBUG: enabled.\n");
+ } else {
+ print("DEBUG: disabled.\n");
+ }
+ }
+ return false;
+ case EEPROM_RESET:
+ if (record->event.pressed) {
+ eeconfig_init();
}
return false;
#ifdef FAUXCLICKY_ENABLE
}
return false;
#endif
- #ifdef RGBLIGHT_ENABLE
+ #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;
}
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(1);
+ rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
}
return false;
case RGB_MODE_BREATHE:
+ #ifdef RGBLIGHT_EFFECT_BREATHING
if (record->event.pressed) {
- if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
+ if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
+ (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
rgblight_step();
} else {
- rgblight_mode(2);
+ rgblight_mode(RGBLIGHT_MODE_BREATHING);
}
}
+ #endif
return false;
case RGB_MODE_RAINBOW:
+ #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
if (record->event.pressed) {
- if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
+ if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
+ (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
rgblight_step();
} else {
- rgblight_mode(6);
+ rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
}
}
+ #endif
return false;
case RGB_MODE_SWIRL:
+ #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
if (record->event.pressed) {
- if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
+ if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
+ (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
rgblight_step();
} else {
- rgblight_mode(9);
+ rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
}
}
+ #endif
return false;
case RGB_MODE_SNAKE:
+ #ifdef RGBLIGHT_EFFECT_SNAKE
if (record->event.pressed) {
- if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
+ if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
+ (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
rgblight_step();
} else {
- rgblight_mode(15);
+ rgblight_mode(RGBLIGHT_MODE_SNAKE);
}
}
+ #endif
return false;
case RGB_MODE_KNIGHT:
+ #ifdef RGBLIGHT_EFFECT_KNIGHT
if (record->event.pressed) {
- if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
+ if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
+ (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
rgblight_step();
} else {
- rgblight_mode(21);
+ rgblight_mode(RGBLIGHT_MODE_KNIGHT);
}
}
+ #endif
return false;
case RGB_MODE_XMAS:
+ #ifdef RGBLIGHT_EFFECT_CHRISTMAS
if (record->event.pressed) {
- rgblight_mode(24);
+ rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
}
+ #endif
return false;
case RGB_MODE_GRADIENT:
+ #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
if (record->event.pressed) {
- if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
+ if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
+ (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
rgblight_step();
} else {
- rgblight_mode(25);
+ 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
- #ifdef PROTOCOL_LUFA
+ 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);
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;
return false;
}
break;
- case KC_LSPO: {
- if (record->event.pressed) {
- shift_interrupted[0] = false;
- scs_timer[0] = timer_read ();
- register_mods(MOD_BIT(KC_LSFT));
- }
- 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));
- }
- return false;
- }
-
- case KC_RSPC: {
- 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));
- }
- return false;
- }
-
- case KC_SFTENT: {
- if (record->event.pressed) {
- shift_interrupted[1] = false;
- scs_timer[1] = timer_read ();
- register_mods(MOD_BIT(KC_RSFT));
- }
- else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
- unregister_mods(MOD_BIT(KC_RSFT));
- register_code(SFTENT_KEY);
- unregister_code(SFTENT_KEY);
- }
- else {
- unregister_mods(MOD_BIT(KC_RSFT));
- }
- return false;
- }
case GRAVE_ESC: {
uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
case BL_BRTG: {
- if (record->event.pressed)
+ if (record->event.pressed) {
breathing_toggle();
+ }
return false;
}
#endif
-
- default: {
- shift_interrupted[0] = true;
- shift_interrupted[1] = true;
- break;
- }
}
return process_action_kb(record);
0, 0, 0, 1, 1, 1, 1, 0
};
+__attribute__ ((weak))
+const bool ascii_to_altgr_lut[0x80] 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,
+ 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
+};
+
__attribute__ ((weak))
const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
0, 0, 0, 0, 0, 0, 0, 0,
while (1) {
char ascii_code = *str;
if (!ascii_code) break;
- if (ascii_code == 1) {
+ if (ascii_code == SS_TAP_CODE) {
// tap
uint8_t keycode = *(++str);
register_code(keycode);
unregister_code(keycode);
- } else if (ascii_code == 2) {
+ } else if (ascii_code == SS_DOWN_CODE) {
// down
uint8_t keycode = *(++str);
register_code(keycode);
- } else if (ascii_code == 3) {
+ } else if (ascii_code == SS_UP_CODE) {
// up
uint8_t keycode = *(++str);
unregister_code(keycode);
while (1) {
char ascii_code = pgm_read_byte(str);
if (!ascii_code) break;
- if (ascii_code == 1) {
+ if (ascii_code == SS_TAP_CODE) {
// tap
uint8_t keycode = pgm_read_byte(++str);
register_code(keycode);
unregister_code(keycode);
- } else if (ascii_code == 2) {
+ } else if (ascii_code == SS_DOWN_CODE) {
// down
uint8_t keycode = pgm_read_byte(++str);
register_code(keycode);
- } else if (ascii_code == 3) {
+ } else if (ascii_code == SS_UP_CODE) {
// up
uint8_t keycode = pgm_read_byte(++str);
unregister_code(keycode);
}
void send_char(char ascii_code) {
- uint8_t keycode;
- keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
- if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
- register_code(KC_LSFT);
- register_code(keycode);
- unregister_code(keycode);
- unregister_code(KC_LSFT);
- } else {
- register_code(keycode);
- unregister_code(keycode);
+ 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);
}
}
default_layer_set(1U<<default_layer);
}
+uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
+ uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
+ uint32_t mask3 = 1UL << layer3;
+ return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
+}
+
void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
- if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
- layer_on(layer3);
- } else {
- layer_off(layer3);
- }
+ layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
}
void tap_random_base64(void) {
}
}
+__attribute__((weak))
+void bootmagic_lite(void) {
+ // The lite version of TMK's bootmagic based on Wilba.
+ // 100% less potential for accidentally making the
+ // keyboard do stupid things.
+
+ // We need multiple scans because debouncing can't be turned off.
+ matrix_scan();
+ #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 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
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
-// depending on the pin, we use a different output compare unit
#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_HARDWARE_PWM
+# 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
-#ifdef NO_HARDWARE_PWM // pwm through software
+void backlight_on(uint8_t backlight_pin) {
+#if BACKLIGHT_ON_STATE == 0
+ writePinLow(backlight_pin);
+#else
+ writePinHigh(backlight_pin);
+#endif
+}
-__attribute__ ((weak))
+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);
+ )
}
__attribute__ ((weak))
#ifndef BACKLIGHT_CUSTOM_DRIVER
void backlight_task(void) {
if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_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);
- #else
- // PORTx |= n
- _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
- #endif
- } 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
+ FOR_EACH_LED(
+ backlight_on(backlight_pin);
+ )
}
- backlight_tick = backlight_tick + 1 % 16;
+ else {
+ FOR_EACH_LED(
+ backlight_off(backlight_pin);
+ )
+ }
+ backlight_tick = (backlight_tick + 1) % 16;
}
#endif
#endif
#endif
-#else // pwm through timer
+#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);
+ )
+}
+
+// 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();
+ }
+#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);
+ )
+ }
+}
+
+#endif
#define TIMER_TOP 0xFFFFU
// 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) {
- OCR1x = val;
+ OCRxx = val;
}
#ifndef BACKLIGHT_CUSTOM_DRIVER
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
// Turn off PWM control on backlight pin
- TCCR1A &= ~(_BV(COM1x1));
+ TCCRxA &= ~(_BV(COMxx1));
+ #endif
} else {
+ #ifdef BACKLIGHT_PWM_TIMER
+ if (!OCRxx) {
+ TIMSKx |= _BV(OCIExA);
+ TIMSKx |= _BV(TOIEx);
+ }
+ #else
// Turn on PWM control of backlight pin
- TCCR1A |= _BV(COM1x1);
+ TCCRxA |= _BV(COMxx1);
+ #endif
}
// Set the brightness
set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
static uint8_t breathing_halt = BREATHING_NO_HALT;
static uint16_t breathing_counter = 0;
+#ifdef BACKLIGHT_PWM_TIMER
+static bool breathing = false;
+
+bool is_breathing(void) {
+ return breathing;
+}
+
+#define breathing_interrupt_enable() do { breathing = true; } while (0)
+#define breathing_interrupt_disable() do { breathing = false; } while (0)
+#else
+
bool is_breathing(void) {
- return !!(TIMSK1 & _BV(TOIE1));
+ return !!(TIMSKx & _BV(TOIEx));
}
-#define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
-#define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
+#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)
return v / BACKLIGHT_LEVELS * get_backlight_level();
}
+#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.
*/
-ISR(TIMER1_OVF_vect)
+ISR(TIMERx_OVF_vect)
+#endif
{
uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
// resetting after one period to prevent ugly reset at overflow.
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);
+ )
+
// 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.)
"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)."
*/
-
- TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
- TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
+ 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.
- ICR1 = TIMER_TOP;
+ ICRx = TIMER_TOP;
backlight_init();
#ifdef BACKLIGHT_BREATHING
#endif
}
-#endif // NO_HARDWARE_PWM
+#endif // hardware backlight
-#else // backlight
+#else // no backlight
__attribute__ ((weak))
void backlight_init_ports(void) {}
#endif // backlight
+#ifdef HD44780_ENABLED
+#include "hd44780.h"
+#endif
+
// Functions for spitting out values
//
// PORTE &= ~(1<<6);
// }
+#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;
+ }
+
+ // Set level without modify backlight_config to keep ability to restore state
+ backlight_set(bl_toggle_lvl);
+#endif
+
led_set_kb(usb_led);
}