M builddefs/common_features.mk => builddefs/common_features.mk +15 -0
@@ 886,9 886,24 @@ ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
endif
endif
+ENCODER_ENABLE ?= no
+ENCODER_DRIVER ?= quadrature
+VALID_ENCODER_DRIVER_TYPES := quadrature custom
ifeq ($(strip $(ENCODER_ENABLE)), yes)
+ ifeq ($(filter $(ENCODER_DRIVER),$(VALID_ENCODER_DRIVER_TYPES)),)
+ $(call CATASTROPHIC_ERROR,Invalid ENCODER_DRIVER,ENCODER_DRIVER="$(ENCODER_DRIVER)" is not a valid encoder driver)
+ endif
SRC += $(QUANTUM_DIR)/encoder.c
OPT_DEFS += -DENCODER_ENABLE
+ OPT_DEFS += -DENCODER_DRIVER_$(strip $(shell echo $(ENCODER_DRIVER) | tr '[:lower:]' '[:upper:]'))
+
+ COMMON_VPATH += $(PLATFORM_PATH)/$(PLATFORM_KEY)/$(DRIVER_DIR)/encoder
+ COMMON_VPATH += $(DRIVER_PATH)/encoder
+
+ ifneq ($(strip $(ENCODER_DRIVER)), custom)
+ SRC += encoder_$(strip $(ENCODER_DRIVER)).c
+ endif
+
ifeq ($(strip $(ENCODER_MAP_ENABLE)), yes)
OPT_DEFS += -DENCODER_MAP_ENABLE
endif
M data/mappings/info_rules.hjson => data/mappings/info_rules.hjson +1 -0
@@ 21,6 21,7 @@
"DEBOUNCE_TYPE": {"info_key": "build.debounce_type"},
"EEPROM_DRIVER": {"info_key": "eeprom.driver"},
"ENCODER_ENABLE": {"info_key": "encoder.enabled", "value_type": "bool"},
+ "ENCODER_DRIVER": {"info_key": "encoder.driver"},
"FIRMWARE_FORMAT": {"info_key": "build.firmware_format"},
"KEYBOARD_SHARED_EP": {"info_key": "usb.shared_endpoint.keyboard", "value_type": "bool"},
"LAYOUTS": {"info_key": "community_layouts", "value_type": "list"},
M data/schemas/keyboard.jsonschema => data/schemas/keyboard.jsonschema +4 -0
@@ 6,6 6,10 @@
"encoder_config": {
"type": "object",
"properties": {
+ "driver": {
+ "type": "string",
+ "enum": ["quadrature", "custom"]
+ },
"rotary": {
"type": "array",
"items": {
A drivers/encoder/encoder_quadrature.c => drivers/encoder/encoder_quadrature.c +213 -0
@@ 0,0 1,213 @@
+// Copyright 2018 Jack Humbert <jack.humb@gmail.com>
+// Copyright 2018-2023 Nick Brassel (@tzarc)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <stdint.h>
+#include "encoder.h"
+#include "gpio.h"
+#include "keyboard.h"
+#include "action.h"
+#include "keycodes.h"
+#include "wait.h"
+
+#ifdef SPLIT_KEYBOARD
+# include "split_util.h"
+#endif
+
+// for memcpy
+#include <string.h>
+
+#if !defined(ENCODER_RESOLUTIONS) && !defined(ENCODER_RESOLUTION)
+# define ENCODER_RESOLUTION 4
+#endif
+
+#undef ENCODER_DEFAULT_PIN_API_IMPL
+#if defined(ENCODERS_PAD_A) && defined(ENCODERS_PAD_B)
+// Inform the quadrature driver that it needs to implement pin init/read functions
+# define ENCODER_DEFAULT_PIN_API_IMPL
+#endif
+
+extern volatile bool isLeftHand;
+
+__attribute__((weak)) void encoder_quadrature_init_pin(uint8_t index, bool pad_b);
+__attribute__((weak)) uint8_t encoder_quadrature_read_pin(uint8_t index, bool pad_b);
+
+#ifdef ENCODER_DEFAULT_PIN_API_IMPL
+
+static pin_t encoders_pad_a[NUM_ENCODERS_MAX_PER_SIDE] = ENCODERS_PAD_A;
+static pin_t encoders_pad_b[NUM_ENCODERS_MAX_PER_SIDE] = ENCODERS_PAD_B;
+
+__attribute__((weak)) void encoder_wait_pullup_charge(void) {
+ wait_us(100);
+}
+
+__attribute__((weak)) void encoder_quadrature_init_pin(uint8_t index, bool pad_b) {
+ pin_t pin = pad_b ? encoders_pad_b[index] : encoders_pad_a[index];
+ if (pin != NO_PIN) {
+ gpio_set_pin_input_high(pin);
+ }
+}
+
+__attribute__((weak)) uint8_t encoder_quadrature_read_pin(uint8_t index, bool pad_b) {
+ pin_t pin = pad_b ? encoders_pad_b[index] : encoders_pad_a[index];
+ if (pin != NO_PIN) {
+ return gpio_read_pin(pin) ? 1 : 0;
+ }
+ return 0;
+}
+
+#endif // ENCODER_DEFAULT_PIN_API_IMPL
+
+#ifdef ENCODER_RESOLUTIONS
+static uint8_t encoder_resolutions[NUM_ENCODERS] = ENCODER_RESOLUTIONS;
+#endif
+
+#ifndef ENCODER_DIRECTION_FLIP
+# define ENCODER_CLOCKWISE true
+# define ENCODER_COUNTER_CLOCKWISE false
+#else
+# define ENCODER_CLOCKWISE false
+# define ENCODER_COUNTER_CLOCKWISE true
+#endif
+static int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
+
+static uint8_t encoder_state[NUM_ENCODERS] = {0};
+static int8_t encoder_pulses[NUM_ENCODERS] = {0};
+
+// encoder counts
+static uint8_t thisCount;
+#ifdef SPLIT_KEYBOARD
+// encoder offsets for each hand
+static uint8_t thisHand, thatHand;
+// encoder counts for each hand
+static uint8_t thatCount;
+#endif
+
+__attribute__((weak)) void encoder_quadrature_post_init_kb(void) {
+ extern void encoder_quadrature_handle_read(uint8_t index, uint8_t pin_a_state, uint8_t pin_b_state);
+ // Unused normally, but can be used for things like setting up pin-change interrupts in keyboard code.
+ // During the interrupt, read the pins then call `encoder_handle_read()` with the pin states and it'll queue up an encoder event if needed.
+}
+
+void encoder_quadrature_post_init(void) {
+#ifdef ENCODER_DEFAULT_PIN_API_IMPL
+ for (uint8_t i = 0; i < thisCount; i++) {
+ encoder_quadrature_init_pin(i, false);
+ encoder_quadrature_init_pin(i, true);
+ }
+ encoder_wait_pullup_charge();
+ for (uint8_t i = 0; i < thisCount; i++) {
+ encoder_state[i] = (encoder_quadrature_read_pin(i, false) << 0) | (encoder_quadrature_read_pin(i, true) << 1);
+ }
+#else
+ memset(encoder_state, 0, sizeof(encoder_state));
+#endif
+
+ encoder_quadrature_post_init_kb();
+}
+
+void encoder_driver_init(void) {
+#ifdef SPLIT_KEYBOARD
+ thisHand = isLeftHand ? 0 : NUM_ENCODERS_LEFT;
+ thatHand = NUM_ENCODERS_LEFT - thisHand;
+ thisCount = isLeftHand ? NUM_ENCODERS_LEFT : NUM_ENCODERS_RIGHT;
+ thatCount = isLeftHand ? NUM_ENCODERS_RIGHT : NUM_ENCODERS_LEFT;
+#else // SPLIT_KEYBOARD
+ thisCount = NUM_ENCODERS;
+#endif
+
+#ifdef ENCODER_TESTS
+ // Annoying that we have to clear out values during initialisation here, but
+ // because all the arrays are static locals, rerunning tests in the same
+ // executable doesn't reset any of these. Kinda crappy having test-only code
+ // here, but it's the simplest solution.
+ memset(encoder_state, 0, sizeof(encoder_state));
+ memset(encoder_pulses, 0, sizeof(encoder_pulses));
+ const pin_t encoders_pad_a_left[] = ENCODERS_PAD_A;
+ const pin_t encoders_pad_b_left[] = ENCODERS_PAD_B;
+ for (uint8_t i = 0; i < thisCount; i++) {
+ encoders_pad_a[i] = encoders_pad_a_left[i];
+ encoders_pad_b[i] = encoders_pad_b_left[i];
+ }
+#endif
+
+#if defined(SPLIT_KEYBOARD) && defined(ENCODERS_PAD_A_RIGHT) && defined(ENCODERS_PAD_B_RIGHT)
+ // Re-initialise the pads if it's the right-hand side
+ if (!isLeftHand) {
+ const pin_t encoders_pad_a_right[] = ENCODERS_PAD_A_RIGHT;
+ const pin_t encoders_pad_b_right[] = ENCODERS_PAD_B_RIGHT;
+ for (uint8_t i = 0; i < thisCount; i++) {
+ encoders_pad_a[i] = encoders_pad_a_right[i];
+ encoders_pad_b[i] = encoders_pad_b_right[i];
+ }
+ }
+#endif // defined(SPLIT_KEYBOARD) && defined(ENCODERS_PAD_A_RIGHT) && defined(ENCODERS_PAD_B_RIGHT)
+
+ // Encoder resolutions is defined differently in config.h, so concatenate
+#if defined(SPLIT_KEYBOARD) && defined(ENCODER_RESOLUTIONS)
+# if defined(ENCODER_RESOLUTIONS_RIGHT)
+ static const uint8_t encoder_resolutions_right[NUM_ENCODERS_RIGHT] = ENCODER_RESOLUTIONS_RIGHT;
+# else // defined(ENCODER_RESOLUTIONS_RIGHT)
+ static const uint8_t encoder_resolutions_right[NUM_ENCODERS_RIGHT] = ENCODER_RESOLUTIONS;
+# endif // defined(ENCODER_RESOLUTIONS_RIGHT)
+ for (uint8_t i = 0; i < NUM_ENCODERS_RIGHT; i++) {
+ encoder_resolutions[NUM_ENCODERS_LEFT + i] = encoder_resolutions_right[i];
+ }
+#endif // defined(SPLIT_KEYBOARD) && defined(ENCODER_RESOLUTIONS)
+
+ encoder_quadrature_post_init();
+}
+
+static void encoder_handle_state_change(uint8_t index, uint8_t state) {
+ uint8_t i = index;
+
+#ifdef SPLIT_KEYBOARD
+ index += thisHand;
+#endif
+
+#ifdef ENCODER_RESOLUTIONS
+ const uint8_t resolution = encoder_resolutions[index];
+#else
+ const uint8_t resolution = ENCODER_RESOLUTION;
+#endif
+
+ encoder_pulses[i] += encoder_LUT[state & 0xF];
+
+#ifdef ENCODER_DEFAULT_POS
+ if ((encoder_pulses[i] >= resolution) || (encoder_pulses[i] <= -resolution) || ((state & 0x3) == ENCODER_DEFAULT_POS)) {
+ if (encoder_pulses[i] >= 1) {
+#else
+ if (encoder_pulses[i] >= resolution) {
+#endif
+
+ encoder_queue_event(index, ENCODER_COUNTER_CLOCKWISE);
+ }
+
+#ifdef ENCODER_DEFAULT_POS
+ if (encoder_pulses[i] <= -1) {
+#else
+ if (encoder_pulses[i] <= -resolution) { // direction is arbitrary here, but this clockwise
+#endif
+ encoder_queue_event(index, ENCODER_CLOCKWISE);
+ }
+ encoder_pulses[i] %= resolution;
+#ifdef ENCODER_DEFAULT_POS
+ encoder_pulses[i] = 0;
+ }
+#endif
+}
+
+void encoder_quadrature_handle_read(uint8_t index, uint8_t pin_a_state, uint8_t pin_b_state) {
+ uint8_t state = pin_a_state | (pin_b_state << 1);
+ if ((encoder_state[index] & 0x3) != state) {
+ encoder_state[index] <<= 2;
+ encoder_state[index] |= state;
+ encoder_handle_state_change(index, encoder_state[index]);
+ }
+}
+
+__attribute__((weak)) void encoder_driver_task(void) {
+ for (uint8_t i = 0; i < thisCount; i++) {
+ encoder_quadrature_handle_read(i, encoder_quadrature_read_pin(i, false), encoder_quadrature_read_pin(i, true));
+ }
+}
M keyboards/mechwild/sugarglider/matrix.c => keyboards/mechwild/sugarglider/matrix.c +4 -2
@@ 50,7 50,7 @@ static void select_row(uint8_t row) {
//wait_us(100);
return;
}
-
+
if (row > 1) {
mcp23018_errors += !mcp23018_set_config(I2C_ADDR, mcp23018_PORTB, ALL_INPUT);
mcp23018_errors += !mcp23018_set_config(I2C_ADDR, mcp23018_PORTA, ~(row_pos[row]));
@@ 87,8 87,10 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
bool changed = false;
for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
changed |= read_cols_on_row(current_matrix, current_row);
+
#ifdef ENCODER_ENABLE
- encoder_read();
+ // Need to frequently read the encoder pins while scanning because the I/O expander takes a long time in comparison.
+ encoder_driver_task();
#endif
}
return changed;
D keyboards/pica40/rev2/post_rules.mk => keyboards/pica40/rev2/post_rules.mk +0 -8
@@ 1,8 0,0 @@
-# if ENCODER_ENABLE is set, add defines but avoid adding encoder.c as it's replaced by custom code in rev2.c
-ifeq ($(strip $(ENCODER_ENABLE)), yes)
- ENCODER_ENABLE := no
- OPT_DEFS += -DENCODER_ENABLE
- ifeq ($(strip $(ENCODER_MAP_ENABLE)), yes)
- OPT_DEFS += -DENCODER_MAP_ENABLE
- endif
-endif
M keyboards/pica40/rev2/rev2.c => keyboards/pica40/rev2/rev2.c +17 -81
@@ 2,99 2,29 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "rev2.h"
+#include "gpio.h"
#ifdef ENCODER_ENABLE // code based on encoder.c
-static const pin_t encoders_pad_a[] = ENCODERS_PAD_A;
-static const pin_t encoders_pad_b[] = ENCODERS_PAD_B;
-
-static int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
-static uint8_t encoder_state = 3;
-static int8_t encoder_pulses = 0;
-static uint8_t encoder_value = 0;
-
-typedef struct encoder_sync_data {
- int value;
-} encoder_sync_data;
+#define ENCODER_PIN_A (((pin_t[])ENCODERS_PAD_A)[0])
+#define ENCODER_PIN_B (((pin_t[])ENCODERS_PAD_B)[0])
// custom handler that returns encoder B pin status from slave side
void encoder_sync_slave_handler(uint8_t in_buflen, const void *in_data, uint8_t out_buflen, void *out_data) {
- encoder_sync_data *data = (encoder_sync_data *)out_data;
- data->value = readPin(encoders_pad_b[0]);
-}
-
-__attribute__((weak)) bool encoder_update_user(uint8_t index, bool clockwise) {
- return true;
+ *(uint8_t *)out_data = readPin(ENCODER_PIN_B) ? 1 : 0;
}
-bool encoder_update_kb(uint8_t index, bool clockwise) {
- if (!encoder_update_user(index, clockwise)) return false;
-
- tap_code(clockwise ? KC_VOLU : KC_VOLD);
+void encoder_quadrature_init_pin(uint8_t index, bool pad_b) {}
- return false;
-}
-
-#ifdef ENCODER_MAP_ENABLE
-static void encoder_exec_mapping(uint8_t index, bool clockwise) {
- action_exec(clockwise ? ENCODER_CW_EVENT(index, true) : ENCODER_CCW_EVENT(index, true));
- wait_ms(ENCODER_MAP_KEY_DELAY);
- action_exec(clockwise ? ENCODER_CW_EVENT(index, false) : ENCODER_CCW_EVENT(index, false));
- wait_ms(ENCODER_MAP_KEY_DELAY);
-}
-#endif // ENCODER_MAP_ENABLE
-
-void encoder_init(void) {
- setPinInputHigh(encoders_pad_a[0]);
- setPinInputHigh(encoders_pad_b[0]);
- wait_us(100);
- transaction_register_rpc(ENCODER_SYNC, encoder_sync_slave_handler);
-}
-
-bool encoder_read(void) {
- // ignore if running on slave side
- if (!is_keyboard_master()) return false;
-
- bool changed = false;
- encoder_sync_data data = {0};
- // request pin B status from slave side
- if (transaction_rpc_recv(ENCODER_SYNC, sizeof(data), &data)) {
- uint8_t new_status = (readPin(encoders_pad_a[0]) << 0) | (data.value << 1);
- if ((encoder_state & 0x3) != new_status) {
- encoder_state <<= 2;
- encoder_state |= new_status;
- encoder_pulses += encoder_LUT[encoder_state & 0xF];
-
- if (encoder_pulses >= ENCODER_RESOLUTION) {
- encoder_value++;
- changed = true;
-#ifdef ENCODER_MAP_ENABLE
- encoder_exec_mapping(0, false);
-#else // ENCODER_MAP_ENABLE
- encoder_update_kb(0, false);
-#endif // ENCODER_MAP_ENABLE
- }
-
- if (encoder_pulses <= -ENCODER_RESOLUTION) {
- encoder_value--;
- changed = true;
-#ifdef ENCODER_MAP_ENABLE
- encoder_exec_mapping(0, true);
-#else // ENCODER_MAP_ENABLE
- encoder_update_kb(0, true);
-#endif // ENCODER_MAP_ENABLE
- }
-
- encoder_pulses %= ENCODER_RESOLUTION;
- }
+uint8_t encoder_quadrature_read_pin(uint8_t index, bool pad_b) {
+ if(pad_b) {
+ uint8_t data = 0;
+ transaction_rpc_recv(ENCODER_SYNC, sizeof(data), &data);
+ return data;
}
- return changed;
+ return readPin(ENCODER_PIN_A) ? 1 : 0;
}
-// do not use standard split encoder transactions
-void encoder_state_raw(uint8_t *slave_state) {}
-void encoder_update_raw(uint8_t *slave_state) {}
-
#endif // ENCODER_ENABLE
#ifdef PICA40_RGBLIGHT_TIMEOUT
@@ 125,6 55,12 @@ bool should_set_rgblight = false;
void keyboard_post_init_kb(void) {
setPinOutput(PICA40_RGB_POWER_PIN);
+#ifdef ENCODER_ENABLE
+ setPinInputHigh(ENCODER_PIN_A);
+ setPinInputHigh(ENCODER_PIN_B);
+ transaction_register_rpc(ENCODER_SYNC, encoder_sync_slave_handler);
+#endif // ENCODER_ENABLE
+
#ifdef PICA40_RGBLIGHT_TIMEOUT
idle_timer = timer_read();
check_rgblight_timer = timer_read();
M keyboards/planck/rev7/info.json => keyboards/planck/rev7/info.json +8 -1
@@ 26,7 26,14 @@
},
"encoder": {
"rotary": [
- {"pin_a": "B12", "pin_b": "B13"}
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"},
+ {"pin_a": "B12", "pin_b": "B13"}
]
},
"features": {
M keyboards/planck/rev7/matrix.c => keyboards/planck/rev7/matrix.c +11 -75
@@ 32,31 32,16 @@
#define STM32_IWDG_RL_MS(s) STM32_IWDG_RL_US(s * 1000.0)
#define STM32_IWDG_RL_S(s) STM32_IWDG_RL_US(s * 1000000.0)
-#if !defined(PLANCK_ENCODER_RESOLUTION)
-# define PLANCK_ENCODER_RESOLUTION 4
-#endif
-
#if !defined(PLANCK_WATCHDOG_TIMEOUT)
# define PLANCK_WATCHDOG_TIMEOUT 1.0
#endif
-#ifdef ENCODER_MAP_ENABLE
-#error "The encoder map feature is not currently supported by the Planck's encoder matrix"
-#endif
-
/* matrix state(1:on, 0:off) */
static pin_t matrix_row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static pin_t matrix_col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static matrix_row_t matrix_inverted[MATRIX_COLS];
-#ifdef ENCODER_ENABLE
-int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
-uint8_t encoder_state[8] = {0};
-int8_t encoder_pulses[8] = {0};
-uint8_t encoder_value[8] = {0};
-#endif
-
void matrix_init_custom(void) {
// actual matrix setup - cols
for (int i = 0; i < MATRIX_COLS; i++) {
@@ 84,31 69,6 @@ void matrix_init_custom(void) {
#endif
}
-#ifdef ENCODER_ENABLE
-bool encoder_update(uint8_t index, uint8_t state) {
- bool changed = false;
- uint8_t i = index;
-
- encoder_pulses[i] += encoder_LUT[state & 0xF];
-
- if (encoder_pulses[i] >= PLANCK_ENCODER_RESOLUTION) {
- encoder_value[index]++;
- changed = true;
- encoder_update_kb(index, false);
- }
- if (encoder_pulses[i] <= -PLANCK_ENCODER_RESOLUTION) {
- encoder_value[index]--;
- changed = true;
- encoder_update_kb(index, true);
- }
- encoder_pulses[i] %= PLANCK_ENCODER_RESOLUTION;
-#ifdef ENCODER_DEFAULT_POS
- encoder_pulses[i] = 0;
-#endif
- return changed;
-}
-#endif
-
bool matrix_scan_custom(matrix_row_t current_matrix[]) {
#ifndef PLANCK_WATCHDOG_DISABLE
// reset watchdog
@@ 149,40 109,16 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
changed |= old != current_matrix[row];
}
-#ifdef ENCODER_ENABLE
- // encoder-matrix functionality
-
- // set up C/rows for encoder read
- for (int i = 0; i < MATRIX_ROWS; i++) {
- setPinOutput(matrix_row_pins[i]);
- writePinHigh(matrix_row_pins[i]);
- }
-
- // set up A & B for reading
- setPinInputHigh(B12);
- setPinInputHigh(B13);
-
- for (int i = 0; i < MATRIX_ROWS; i++) {
- writePinLow(matrix_row_pins[i]);
- wait_us(10);
- uint8_t new_status = (palReadPad(GPIOB, 12) << 0) | (palReadPad(GPIOB, 13) << 1);
- if ((encoder_state[i] & 0x3) != new_status) {
- encoder_state[i] <<= 2;
- encoder_state[i] |= new_status;
- encoder_update(i, encoder_state[i]);
- }
- writePinHigh(matrix_row_pins[i]);
- }
-
- // revert A & B to matrix state
- setPinInputLow(B12);
- setPinInputLow(B13);
-
- // revert C/rows to matrix state
- for (int i = 0; i < MATRIX_ROWS; i++) {
- setPinInputLow(matrix_row_pins[i]);
- }
-#endif
-
return changed;
}
+
+uint8_t encoder_quadrature_read_pin(uint8_t index, bool pad_b) {
+ pin_t pin = pad_b ? B13: B12;
+ setPinInputHigh(pin);
+ writePinLow(matrix_row_pins[index]);
+ wait_us(10);
+ uint8_t ret = readPin(pin) ? 1 : 0;
+ setPinInputLow(matrix_row_pins[index]);
+ setPinInputLow(pin);
+ return ret;
+}
M keyboards/ploopyco/mouse/config.h => keyboards/ploopyco/mouse/config.h +3 -0
@@ 32,3 32,6 @@
/* PMW33XX Settings */
#define PMW33XX_CS_PIN B0
+
+/* Custom encoder needs to specify just how many encoders we have */
+#define NUM_ENCODERS 1
M keyboards/ploopyco/mouse/info.json => keyboards/ploopyco/mouse/info.json +6 -0
@@ 31,6 31,12 @@
["D4", "D2", "E6", "B6", "D7", "C6", "C7", "B7"]
]
},
+ "features": {
+ "encoder": true
+ },
+ "encoder": {
+ "driver": "custom"
+ },
"layouts": {
"LAYOUT": {
"layout": [
M keyboards/ploopyco/mouse/mouse.c => keyboards/ploopyco/mouse/mouse.c +9 -11
@@ 66,8 66,6 @@ uint8_t OptLowPin = OPT_ENC1;
bool debug_encoder = false;
bool is_drag_scroll = false;
-__attribute__((weak)) bool encoder_update_user(uint8_t index, bool clockwise) { return true; }
-
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!encoder_update_user(index, clockwise)) {
return false;
@@ 83,7 81,14 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
return true;
}
-void process_wheel(void) {
+void encoder_driver_init(void) {
+ setPinInput(OPT_ENC1);
+ setPinInput(OPT_ENC2);
+
+ opt_encoder_init();
+}
+
+void encoder_driver_task(void) {
// Lovingly ripped from the Ploopy Source
// If the mouse wheel was just released, do not scroll.
@@ 111,12 116,10 @@ void process_wheel(void) {
int dir = opt_encoder_handler(p1, p2);
if (dir == 0) return;
- encoder_update_kb(0, dir > 0);
+ encoder_queue_event(0, dir == 1);
}
report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
- process_wheel();
-
if (is_drag_scroll) {
mouse_report.h = mouse_report.x;
#ifdef PLOOPY_DRAGSCROLL_INVERT
@@ 177,9 180,6 @@ void keyboard_pre_init_kb(void) {
// debug_mouse = true;
// debug_encoder = true;
- setPinInput(OPT_ENC1);
- setPinInput(OPT_ENC2);
-
/* Ground all output pins connected to ground. This provides additional
* pathways to ground. If you're messing with this, know this: driving ANY
* of these pins high will cause a short. On the MCU. Ka-blooey.
@@ 204,8 204,6 @@ void keyboard_pre_init_kb(void) {
void pointing_device_init_kb(void) {
pointing_device_set_cpi(dpi_array[keyboard_config.dpi_config]);
- // initialize the scroll wheel's optical encoder
- opt_encoder_init();
}
void eeconfig_init_kb(void) {
M keyboards/ploopyco/mouse/rules.mk => keyboards/ploopyco/mouse/rules.mk +0 -3
@@ 16,9 16,6 @@ POINTING_DEVICE_ENABLE = yes
POINTING_DEVICE_DRIVER = pmw3360
MOUSEKEY_ENABLE = yes # Mouse keys
-ENCODER_ENABLE := no
-OPTS_DEF += -DENCODER_ENABLE
-
ANALOG_DRIVER_REQUIRED = yes
SRC += opt_encoder.c
M keyboards/ploopyco/trackball/config.h => keyboards/ploopyco/trackball/config.h +3 -0
@@ 31,3 31,6 @@
/* PMW33XX Settings */
#define PMW33XX_CS_PIN B0
#define POINTING_DEVICE_INVERT_Y
+
+/* Custom encoder needs to specify just how many encoders we have */
+#define NUM_ENCODERS 1
M keyboards/ploopyco/trackball/info.json => keyboards/ploopyco/trackball/info.json +6 -0
@@ 12,6 12,12 @@
"bootmagic": {
"matrix": [0, 3]
},
+ "features": {
+ "encoder": true
+ },
+ "encoder": {
+ "driver": "custom"
+ },
"layouts": {
"LAYOUT": {
"layout": [
M keyboards/ploopyco/trackball/rules.mk => keyboards/ploopyco/trackball/rules.mk +0 -3
@@ 16,9 16,6 @@ POINTING_DEVICE_ENABLE = yes
POINTING_DEVICE_DRIVER = pmw3360
MOUSEKEY_ENABLE = yes # Mouse keys
-ENCODER_ENABLE := no
-OPTS_DEF += -DENCODER_ENABLE
-
ANALOG_DRIVER_REQUIRED = yes
SRC += opt_encoder.c
M keyboards/ploopyco/trackball/trackball.c => keyboards/ploopyco/trackball/trackball.c +10 -10
@@ 66,8 66,6 @@ uint8_t OptLowPin = OPT_ENC1;
bool debug_encoder = false;
bool is_drag_scroll = false;
-__attribute__((weak)) bool encoder_update_user(uint8_t index, bool clockwise) { return true; }
-
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!encoder_update_user(index, clockwise)) {
return false;
@@ 83,7 81,15 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
return true;
}
-void process_wheel(void) {
+
+void encoder_driver_init(void) {
+ setPinInput(OPT_ENC1);
+ setPinInput(OPT_ENC2);
+
+ opt_encoder_init();
+}
+
+void encoder_driver_task(void) {
// TODO: Replace this with interrupt driven code, polling is S L O W
// Lovingly ripped from the Ploopy Source
@@ 112,11 118,10 @@ void process_wheel(void) {
int dir = opt_encoder_handler(p1, p2);
if (dir == 0) return;
- encoder_update_kb(0, dir > 0);
+ encoder_queue_event(0, dir == 1);
}
report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
- process_wheel();
if (is_drag_scroll) {
#ifdef PLOOPY_DRAGSCROLL_H_INVERT
@@ 189,9 194,6 @@ void keyboard_pre_init_kb(void) {
// debug_mouse = true;
// debug_encoder = true;
- setPinInput(OPT_ENC1);
- setPinInput(OPT_ENC2);
-
/* Ground all output pins connected to ground. This provides additional
* pathways to ground. If you're messing with this, know this: driving ANY
* of these pins high will cause a short. On the MCU. Ka-blooey.
@@ 216,8 218,6 @@ void keyboard_pre_init_kb(void) {
void pointing_device_init_kb(void) {
pointing_device_set_cpi(dpi_array[keyboard_config.dpi_config]);
- // initialize the scroll wheel's optical encoder
- opt_encoder_init();
}
void eeconfig_init_kb(void) {
M keyboards/ploopyco/trackball_mini/config.h => keyboards/ploopyco/trackball_mini/config.h +3 -0
@@ 32,3 32,6 @@
#define ADNS5050_CS_PIN B4
#define POINTING_DEVICE_ROTATION_270
+
+/* Custom encoder needs to specify just how many encoders we have */
+#define NUM_ENCODERS 1
M keyboards/ploopyco/trackball_mini/info.json => keyboards/ploopyco/trackball_mini/info.json +6 -0
@@ 14,6 14,12 @@
},
"processor": "atmega32u4",
"bootloader": "atmel-dfu",
+ "features": {
+ "encoder": true
+ },
+ "encoder": {
+ "driver": "custom"
+ },
"layouts": {
"LAYOUT": {
"layout": [
M keyboards/ploopyco/trackball_mini/rules.mk => keyboards/ploopyco/trackball_mini/rules.mk +0 -3
@@ 13,9 13,6 @@ POINTING_DEVICE_ENABLE = yes
POINTING_DEVICE_DRIVER = adns5050
MOUSEKEY_ENABLE = yes # Mouse keys
-ENCODER_ENABLE := no
-OPTS_DEF += -DENCODER_ENABLE
-
ANALOG_DRIVER_REQUIRED = yes
SRC += opt_encoder.c
M keyboards/ploopyco/trackball_mini/trackball_mini.c => keyboards/ploopyco/trackball_mini/trackball_mini.c +9 -11
@@ 74,8 74,6 @@ uint8_t OptLowPin = OPT_ENC1;
bool debug_encoder = false;
bool is_drag_scroll = false;
-__attribute__((weak)) bool encoder_update_user(uint8_t index, bool clockwise) { return true; }
-
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!encoder_update_user(index, clockwise)) {
return false;
@@ 91,7 89,14 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
return true;
}
-void process_wheel(void) {
+void encoder_driver_init(void) {
+ setPinInput(OPT_ENC1);
+ setPinInput(OPT_ENC2);
+
+ opt_encoder_init();
+}
+
+void encoder_driver_task(void) {
uint16_t p1 = adc_read(OPT_ENC1_MUX);
uint16_t p2 = adc_read(OPT_ENC2_MUX);
@@ 113,21 118,17 @@ void process_wheel(void) {
}
if (dir == 0) return;
- encoder_update_kb(0, dir > 0);
+ encoder_queue_event(0, dir == 1);
lastScroll = timer_read();
}
void pointing_device_init_kb(void) {
- opt_encoder_init();
-
// set the DPI.
pointing_device_set_cpi(dpi_array[keyboard_config.dpi_config]);
}
report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
- process_wheel();
-
if (is_drag_scroll) {
mouse_report.h = mouse_report.x;
#ifdef PLOOPY_DRAGSCROLL_INVERT
@@ 180,9 181,6 @@ void keyboard_pre_init_kb(void) {
// debug_mouse = true;
// debug_encoder = true;
- setPinInput(OPT_ENC1);
- setPinInput(OPT_ENC2);
-
/* Ground all output pins connected to ground. This provides additional
* pathways to ground. If you're messing with this, know this: driving ANY
* of these pins high will cause a short. On the MCU. Ka-blooey.
M keyboards/ploopyco/trackball_thumb/config.h => keyboards/ploopyco/trackball_thumb/config.h +3 -0
@@ 31,3 31,6 @@
/* PMW3360 Settings */
#define POINTING_DEVICE_CS_PIN B0
+
+/* Custom encoder needs to specify just how many encoders we have */
+#define NUM_ENCODERS 1
M keyboards/ploopyco/trackball_thumb/info.json => keyboards/ploopyco/trackball_thumb/info.json +4 -1
@@ 18,7 18,10 @@
"mousekey": true,
"nkro": true,
"pointing_device": true,
- "encoder": false
+ "encoder": true
+ },
+ "encoder": {
+ "driver": "custom"
},
"layouts": {
"LAYOUT": {
D keyboards/ploopyco/trackball_thumb/post_rules.mk => keyboards/ploopyco/trackball_thumb/post_rules.mk +0 -4
@@ 1,4 0,0 @@
-# Force encoder to be disabled
-# But enable the defines for it
-ENCODER_ENABLE := no
-OPT_DEFS += -DENCODER_ENABLE
M keyboards/ploopyco/trackball_thumb/trackball_thumb.c => keyboards/ploopyco/trackball_thumb/trackball_thumb.c +8 -12
@@ 17,6 17,7 @@
*/
#include "trackball_thumb.h"
+#include "encoder.h"
#ifndef OPT_DEBOUNCE
# define OPT_DEBOUNCE 5 // (ms) Time between scroll events
@@ 57,9 58,6 @@ uint16_t last_mid_click = 0; // Stops scrollwheel from being read if it was
bool debug_encoder = false;
bool is_drag_scroll = false;
-// require, since core encoder.c (where is is normally defined isn't present
-__attribute__((weak)) bool encoder_update_user(uint8_t index, bool clockwise) { return true; }
-
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!encoder_update_user(index, clockwise)) {
return false;
@@ 75,25 73,25 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
return true;
}
-void encoder_init(void) { opt_encoder_init(); }
+void encoder_driver_init(void) { opt_encoder_init(); }
-bool encoder_read(void) {
+void encoder_driver_task(void) {
// Lovingly ripped from the Ploopy Source
// If the mouse wheel was just released, do not scroll.
if (timer_elapsed(last_mid_click) < SCROLL_BUTT_DEBOUNCE) {
- return false;
+ return;
}
// Limit the number of scrolls per unit time.
if (timer_elapsed(last_scroll) < OPT_DEBOUNCE) {
- return false;
+ return;
}
// Don't scroll if the middle button is depressed.
if (is_scroll_clicked) {
#ifndef IGNORE_SCROLL_CLICK
- return false;
+ return;
#endif
}
@@ 104,10 102,8 @@ bool encoder_read(void) {
int dir = opt_encoder_handler(p1, p2);
- if (dir == 0) return false;
- ;
- encoder_update_kb(0, dir == 1);
- return true;
+ if (dir == 0) return;
+ encoder_queue_event(0, dir == 1);
}
report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
M keyboards/ploopyco/trackball_thumb/trackball_thumb.h => keyboards/ploopyco/trackball_thumb/trackball_thumb.h +0 -3
@@ 28,9 28,6 @@
#define OPT_ENC1_MUX 4
#define OPT_ENC2_MUX 0
-bool encoder_update_kb(uint8_t index, bool clockwise);
-bool encoder_update_user(uint8_t index, bool clockwise);
-
typedef union {
uint32_t raw;
struct {
M quantum/encoder.c => quantum/encoder.c +88 -248
@@ 1,81 1,110 @@
-/*
- * Copyright 2018 Jack Humbert <jack.humb@gmail.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2022-2023 Nick Brassel (@tzarc)
+// SPDX-License-Identifier: GPL-2.0-or-later
-#include "encoder.h"
-#include "keyboard.h"
+#include <string.h>
#include "action.h"
-#include "keycodes.h"
+#include "encoder.h"
#include "wait.h"
-#ifdef SPLIT_KEYBOARD
-# include "split_util.h"
-#endif
-
-// for memcpy
-#include <string.h>
-
#ifndef ENCODER_MAP_KEY_DELAY
-# include "action.h"
# define ENCODER_MAP_KEY_DELAY TAP_CODE_DELAY
#endif
-#if !defined(ENCODER_RESOLUTIONS) && !defined(ENCODER_RESOLUTION)
-# define ENCODER_RESOLUTION 4
-#endif
+__attribute__((weak)) bool should_process_encoder(void) {
+ return is_keyboard_master();
+}
-#if !defined(ENCODERS_PAD_A) || !defined(ENCODERS_PAD_B)
-# error "No encoder pads defined by ENCODERS_PAD_A and ENCODERS_PAD_B"
-#endif
+static encoder_events_t encoder_events;
+
+void encoder_init(void) {
+ memset(&encoder_events, 0, sizeof(encoder_events));
+ encoder_driver_init();
+}
-extern volatile bool isLeftHand;
+static bool encoder_handle_queue(void) {
+ bool changed = false;
+ while (encoder_events.tail != encoder_events.head) {
+ encoder_event_t event = encoder_events.queue[encoder_events.tail];
+ encoder_events.tail = (encoder_events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
-static pin_t encoders_pad_a[NUM_ENCODERS_MAX_PER_SIDE] = ENCODERS_PAD_A;
-static pin_t encoders_pad_b[NUM_ENCODERS_MAX_PER_SIDE] = ENCODERS_PAD_B;
+#ifdef ENCODER_MAP_ENABLE
-#ifdef ENCODER_RESOLUTIONS
-static uint8_t encoder_resolutions[NUM_ENCODERS] = ENCODER_RESOLUTIONS;
-#endif
+ // The delays below cater for Windows and its wonderful requirements.
+ action_exec(event.clockwise ? MAKE_ENCODER_CW_EVENT(event.index, true) : MAKE_ENCODER_CCW_EVENT(event.index, true));
+# if ENCODER_MAP_KEY_DELAY > 0
+ wait_ms(ENCODER_MAP_KEY_DELAY);
+# endif // ENCODER_MAP_KEY_DELAY > 0
-#ifndef ENCODER_DIRECTION_FLIP
-# define ENCODER_CLOCKWISE true
-# define ENCODER_COUNTER_CLOCKWISE false
-#else
-# define ENCODER_CLOCKWISE false
-# define ENCODER_COUNTER_CLOCKWISE true
-#endif
-static int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
+ action_exec(event.clockwise ? MAKE_ENCODER_CW_EVENT(event.index, false) : MAKE_ENCODER_CCW_EVENT(event.index, false));
+# if ENCODER_MAP_KEY_DELAY > 0
+ wait_ms(ENCODER_MAP_KEY_DELAY);
+# endif // ENCODER_MAP_KEY_DELAY > 0
+
+#else // ENCODER_MAP_ENABLE
+
+ encoder_update_kb(event.index, event.clockwise ? true : false);
+
+#endif // ENCODER_MAP_ENABLE
+
+ changed = true;
+ }
+ return changed;
+}
-static uint8_t encoder_state[NUM_ENCODERS] = {0};
-static int8_t encoder_pulses[NUM_ENCODERS] = {0};
+bool encoder_task(void) {
+ bool changed = false;
-// encoder counts
-static uint8_t thisCount;
#ifdef SPLIT_KEYBOARD
-// encoder offsets for each hand
-static uint8_t thisHand, thatHand;
-// encoder counts for each hand
-static uint8_t thatCount;
-#endif
+ // Attempt to process existing encoder events in case split handling has already enqueued events
+ if (should_process_encoder()) {
+ changed |= encoder_handle_queue();
+ }
+#endif // SPLIT_KEYBOARD
+
+ // Let the encoder driver produce events
+ encoder_driver_task();
+
+ // Process any events that were enqueued
+ if (should_process_encoder()) {
+ changed |= encoder_handle_queue();
+ }
+
+ return changed;
+}
+
+bool encoder_queue_event(uint8_t index, bool clockwise) {
+ // Drop out if we're full
+ if ((encoder_events.head + 1) % MAX_QUEUED_ENCODER_EVENTS == encoder_events.tail) {
+ return false;
+ }
+
+ // Append the event
+ encoder_event_t new_event = {.index = index, .clockwise = clockwise ? 1 : 0};
+ encoder_events.queue[encoder_events.head] = new_event;
+
+ // Increment the head index
+ encoder_events.head = (encoder_events.head + 1) % MAX_QUEUED_ENCODER_EVENTS;
+
+ return true;
+}
+
+void encoder_retrieve_events(encoder_events_t *events) {
+ memcpy(events, &encoder_events, sizeof(encoder_events));
+}
-static uint8_t encoder_value[NUM_ENCODERS] = {0};
+#ifdef SPLIT_KEYBOARD
+void encoder_set_tail_index(uint8_t tail_index) {
+ encoder_events.tail = tail_index;
+}
-__attribute__((weak)) void encoder_wait_pullup_charge(void) {
- wait_us(100);
+void encoder_handle_slave_events(encoder_events_t *events) {
+ while (events->tail != events->head) {
+ encoder_event_t event = events->queue[events->tail];
+ events->tail = (events->tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ encoder_queue_event(event.index, event.clockwise ? true : false);
+ }
}
+#endif // SPLIT_KEYBOARD
__attribute__((weak)) bool encoder_update_user(uint8_t index, bool clockwise) {
return true;
@@ 106,192 135,3 @@ __attribute__((weak)) bool encoder_update_kb(uint8_t index, bool clockwise) {
#endif // ENCODER_TESTS
return res;
}
-
-__attribute__((weak)) bool should_process_encoder(void) {
- return is_keyboard_master();
-}
-
-void encoder_init(void) {
-#ifdef SPLIT_KEYBOARD
- thisHand = isLeftHand ? 0 : NUM_ENCODERS_LEFT;
- thatHand = NUM_ENCODERS_LEFT - thisHand;
- thisCount = isLeftHand ? NUM_ENCODERS_LEFT : NUM_ENCODERS_RIGHT;
- thatCount = isLeftHand ? NUM_ENCODERS_RIGHT : NUM_ENCODERS_LEFT;
-#else // SPLIT_KEYBOARD
- thisCount = NUM_ENCODERS;
-#endif
-
-#ifdef ENCODER_TESTS
- // Annoying that we have to clear out values during initialisation here, but
- // because all the arrays are static locals, rerunning tests in the same
- // executable doesn't reset any of these. Kinda crappy having test-only code
- // here, but it's the simplest solution.
- memset(encoder_value, 0, sizeof(encoder_value));
- memset(encoder_state, 0, sizeof(encoder_state));
- memset(encoder_pulses, 0, sizeof(encoder_pulses));
- static const pin_t encoders_pad_a_left[] = ENCODERS_PAD_A;
- static const pin_t encoders_pad_b_left[] = ENCODERS_PAD_B;
- for (uint8_t i = 0; i < thisCount; i++) {
- encoders_pad_a[i] = encoders_pad_a_left[i];
- encoders_pad_b[i] = encoders_pad_b_left[i];
- }
-#endif
-
-#if defined(SPLIT_KEYBOARD) && defined(ENCODERS_PAD_A_RIGHT) && defined(ENCODERS_PAD_B_RIGHT)
- // Re-initialise the pads if it's the right-hand side
- if (!isLeftHand) {
- static const pin_t encoders_pad_a_right[] = ENCODERS_PAD_A_RIGHT;
- static const pin_t encoders_pad_b_right[] = ENCODERS_PAD_B_RIGHT;
- for (uint8_t i = 0; i < thisCount; i++) {
- encoders_pad_a[i] = encoders_pad_a_right[i];
- encoders_pad_b[i] = encoders_pad_b_right[i];
- }
- }
-#endif // defined(SPLIT_KEYBOARD) && defined(ENCODERS_PAD_A_RIGHT) && defined(ENCODERS_PAD_B_RIGHT)
-
- // Encoder resolutions is handled purely master-side, so concatenate the two arrays
-#if defined(SPLIT_KEYBOARD) && defined(ENCODER_RESOLUTIONS)
-# if defined(ENCODER_RESOLUTIONS_RIGHT)
- static const uint8_t encoder_resolutions_right[NUM_ENCODERS_RIGHT] = ENCODER_RESOLUTIONS_RIGHT;
-# else // defined(ENCODER_RESOLUTIONS_RIGHT)
- static const uint8_t encoder_resolutions_right[NUM_ENCODERS_RIGHT] = ENCODER_RESOLUTIONS;
-# endif // defined(ENCODER_RESOLUTIONS_RIGHT)
- for (uint8_t i = 0; i < NUM_ENCODERS_RIGHT; i++) {
- encoder_resolutions[NUM_ENCODERS_LEFT + i] = encoder_resolutions_right[i];
- }
-#endif // defined(SPLIT_KEYBOARD) && defined(ENCODER_RESOLUTIONS)
-
- for (uint8_t i = 0; i < thisCount; i++) {
- gpio_set_pin_input_high(encoders_pad_a[i]);
- gpio_set_pin_input_high(encoders_pad_b[i]);
- }
- encoder_wait_pullup_charge();
- for (uint8_t i = 0; i < thisCount; i++) {
- encoder_state[i] = (gpio_read_pin(encoders_pad_a[i]) << 0) | (gpio_read_pin(encoders_pad_b[i]) << 1);
- }
-}
-
-#ifdef ENCODER_MAP_ENABLE
-static void encoder_exec_mapping(uint8_t index, bool clockwise) {
- // The delays below cater for Windows and its wonderful requirements.
- action_exec(clockwise ? MAKE_ENCODER_CW_EVENT(index, true) : MAKE_ENCODER_CCW_EVENT(index, true));
-# if ENCODER_MAP_KEY_DELAY > 0
- wait_ms(ENCODER_MAP_KEY_DELAY);
-# endif // ENCODER_MAP_KEY_DELAY > 0
-
- action_exec(clockwise ? MAKE_ENCODER_CW_EVENT(index, false) : MAKE_ENCODER_CCW_EVENT(index, false));
-# if ENCODER_MAP_KEY_DELAY > 0
- wait_ms(ENCODER_MAP_KEY_DELAY);
-# endif // ENCODER_MAP_KEY_DELAY > 0
-}
-#endif // ENCODER_MAP_ENABLE
-
-static bool encoder_update(uint8_t index, uint8_t state) {
- bool changed = false;
- uint8_t i = index;
-
-#ifdef ENCODER_RESOLUTIONS
- const uint8_t resolution = encoder_resolutions[i];
-#else
- const uint8_t resolution = ENCODER_RESOLUTION;
-#endif
-
-#ifdef SPLIT_KEYBOARD
- index += thisHand;
-#endif
- encoder_pulses[i] += encoder_LUT[state & 0xF];
-
-#ifdef ENCODER_DEFAULT_POS
- if ((encoder_pulses[i] >= resolution) || (encoder_pulses[i] <= -resolution) || ((state & 0x3) == ENCODER_DEFAULT_POS)) {
- if (encoder_pulses[i] >= 1) {
-#else
- if (encoder_pulses[i] >= resolution) {
-#endif
-
- encoder_value[index]++;
- changed = true;
-#ifdef SPLIT_KEYBOARD
- if (should_process_encoder())
-#endif // SPLIT_KEYBOARD
-#ifdef ENCODER_MAP_ENABLE
- encoder_exec_mapping(index, ENCODER_COUNTER_CLOCKWISE);
-#else // ENCODER_MAP_ENABLE
- encoder_update_kb(index, ENCODER_COUNTER_CLOCKWISE);
-#endif // ENCODER_MAP_ENABLE
- }
-
-#ifdef ENCODER_DEFAULT_POS
- if (encoder_pulses[i] <= -1) {
-#else
- if (encoder_pulses[i] <= -resolution) { // direction is arbitrary here, but this clockwise
-#endif
- encoder_value[index]--;
- changed = true;
-#ifdef SPLIT_KEYBOARD
- if (should_process_encoder())
-#endif // SPLIT_KEYBOARD
-#ifdef ENCODER_MAP_ENABLE
- encoder_exec_mapping(index, ENCODER_CLOCKWISE);
-#else // ENCODER_MAP_ENABLE
- encoder_update_kb(index, ENCODER_CLOCKWISE);
-#endif // ENCODER_MAP_ENABLE
- }
- encoder_pulses[i] %= resolution;
-#ifdef ENCODER_DEFAULT_POS
- encoder_pulses[i] = 0;
- }
-#endif
- return changed;
-}
-
-bool encoder_read(void) {
- bool changed = false;
- for (uint8_t i = 0; i < thisCount; i++) {
- uint8_t new_status = (gpio_read_pin(encoders_pad_a[i]) << 0) | (gpio_read_pin(encoders_pad_b[i]) << 1);
- if ((encoder_state[i] & 0x3) != new_status) {
- encoder_state[i] <<= 2;
- encoder_state[i] |= new_status;
- changed |= encoder_update(i, encoder_state[i]);
- }
- }
- return changed;
-}
-
-#ifdef SPLIT_KEYBOARD
-void last_encoder_activity_trigger(void);
-
-void encoder_state_raw(uint8_t *slave_state) {
- memcpy(slave_state, &encoder_value[thisHand], sizeof(uint8_t) * thisCount);
-}
-
-void encoder_update_raw(uint8_t *slave_state) {
- bool changed = false;
- for (uint8_t i = 0; i < thatCount; i++) { // Note inverted logic -- we want the opposite side
- const uint8_t index = i + thatHand;
- int8_t delta = slave_state[i] - encoder_value[index];
- while (delta > 0) {
- delta--;
- encoder_value[index]++;
- changed = true;
-# ifdef ENCODER_MAP_ENABLE
- encoder_exec_mapping(index, ENCODER_COUNTER_CLOCKWISE);
-# else // ENCODER_MAP_ENABLE
- encoder_update_kb(index, ENCODER_COUNTER_CLOCKWISE);
-# endif // ENCODER_MAP_ENABLE
- }
- while (delta < 0) {
- delta++;
- encoder_value[index]--;
- changed = true;
-# ifdef ENCODER_MAP_ENABLE
- encoder_exec_mapping(index, ENCODER_CLOCKWISE);
-# else // ENCODER_MAP_ENABLE
- encoder_update_kb(index, ENCODER_CLOCKWISE);
-# endif // ENCODER_MAP_ENABLE
- }
- }
-
- // Update the last encoder input time -- handled external to encoder_read() when we're running a split
- if (changed) last_encoder_activity_trigger();
-}
-#endif
M quantum/encoder.h => quantum/encoder.h +71 -28
@@ 22,45 22,88 @@
#include "gpio.h"
#include "util.h"
+#ifdef ENCODER_ENABLE
+
+__attribute__((weak)) bool should_process_encoder(void);
+
void encoder_init(void);
-bool encoder_read(void);
+bool encoder_task(void);
+bool encoder_queue_event(uint8_t index, bool clockwise);
bool encoder_update_kb(uint8_t index, bool clockwise);
bool encoder_update_user(uint8_t index, bool clockwise);
-#ifdef SPLIT_KEYBOARD
+# ifdef SPLIT_KEYBOARD
+
+# if defined(ENCODERS_PAD_A_RIGHT)
+# ifndef NUM_ENCODERS_LEFT
+# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A))
+# endif
+# ifndef NUM_ENCODERS_RIGHT
+# define NUM_ENCODERS_RIGHT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A_RIGHT))
+# endif
+# else
+# ifndef NUM_ENCODERS_LEFT
+# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A))
+# endif
+# ifndef NUM_ENCODERS_RIGHT
+# define NUM_ENCODERS_RIGHT NUM_ENCODERS_LEFT
+# endif
+# endif
+# ifndef NUM_ENCODERS
+# define NUM_ENCODERS (NUM_ENCODERS_LEFT + NUM_ENCODERS_RIGHT)
+# endif
+
+# else // SPLIT_KEYBOARD
-void encoder_state_raw(uint8_t* slave_state);
-void encoder_update_raw(uint8_t* slave_state);
+# ifndef NUM_ENCODERS
+# define NUM_ENCODERS ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A))
+# endif
+# define NUM_ENCODERS_LEFT NUM_ENCODERS
+# define NUM_ENCODERS_RIGHT 0
-# if defined(ENCODERS_PAD_A_RIGHT)
-# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A))
-# define NUM_ENCODERS_RIGHT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A_RIGHT))
-# else
-# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A))
-# define NUM_ENCODERS_RIGHT NUM_ENCODERS_LEFT
-# endif
-# define NUM_ENCODERS (NUM_ENCODERS_LEFT + NUM_ENCODERS_RIGHT)
+# endif // SPLIT_KEYBOARD
-#else // SPLIT_KEYBOARD
+# ifndef NUM_ENCODERS
+# define NUM_ENCODERS 0
+# define NUM_ENCODERS_LEFT 0
+# define NUM_ENCODERS_RIGHT 0
+# endif // NUM_ENCODERS
-# define NUM_ENCODERS ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A))
-# define NUM_ENCODERS_LEFT NUM_ENCODERS
-# define NUM_ENCODERS_RIGHT 0
+# define NUM_ENCODERS_MAX_PER_SIDE MAX(NUM_ENCODERS_LEFT, NUM_ENCODERS_RIGHT)
-#endif // SPLIT_KEYBOARD
+# ifndef MAX_QUEUED_ENCODER_EVENTS
+# define MAX_QUEUED_ENCODER_EVENTS MAX(4, ((NUM_ENCODERS_MAX_PER_SIDE) + 1))
+# endif // MAX_QUEUED_ENCODER_EVENTS
-#ifndef NUM_ENCODERS
-# define NUM_ENCODERS 0
-# define NUM_ENCODERS_LEFT 0
-# define NUM_ENCODERS_RIGHT 0
-#endif // NUM_ENCODERS
+typedef struct encoder_event_t {
+ uint8_t index : 7;
+ uint8_t clockwise : 1;
+} encoder_event_t;
-#define NUM_ENCODERS_MAX_PER_SIDE MAX(NUM_ENCODERS_LEFT, NUM_ENCODERS_RIGHT)
+typedef struct encoder_events_t {
+ uint8_t head;
+ uint8_t tail;
+ encoder_event_t queue[MAX_QUEUED_ENCODER_EVENTS];
+} encoder_events_t;
-#ifdef ENCODER_MAP_ENABLE
-# define NUM_DIRECTIONS 2
-# define ENCODER_CCW_CW(ccw, cw) \
- { (cw), (ccw) }
+// Get the current queued events
+void encoder_retrieve_events(encoder_events_t *events);
+
+# ifdef SPLIT_KEYBOARD
+void encoder_set_tail_index(uint8_t tail_index);
+void encoder_handle_slave_events(encoder_events_t *events);
+# endif // SPLIT_KEYBOARD
+
+# ifdef ENCODER_MAP_ENABLE
+# define NUM_DIRECTIONS 2
+# define ENCODER_CCW_CW(ccw, cw) \
+ { (cw), (ccw) }
extern const uint16_t encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS];
-#endif // ENCODER_MAP_ENABLE
+# endif // ENCODER_MAP_ENABLE
+
+// "Custom encoder lite" support
+void encoder_driver_init(void);
+void encoder_driver_task(void);
+
+#endif // ENCODER_ENABLE
A quantum/encoder/tests/config_encoder_common.h => quantum/encoder/tests/config_encoder_common.h +6 -0
@@ 0,0 1,6 @@
+// Copyright 2023 Nick Brassel (@tzarc)
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+// Override the one in quantum/util because it doesn't like working on x64 builds.
+#define ARRAY_SIZE(array) (sizeof((array)) / sizeof((array)[0]))
M quantum/encoder/tests/config_mock.h => quantum/encoder/tests/config_mock.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/config_mock_split_left_eq_right.h => quantum/encoder/tests/config_mock_split_left_eq_right.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/config_mock_split_left_gt_right.h => quantum/encoder/tests/config_mock_split_left_gt_right.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/config_mock_split_left_lt_right.h => quantum/encoder/tests/config_mock_split_left_lt_right.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/config_mock_split_no_left.h => quantum/encoder/tests/config_mock_split_no_left.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/config_mock_split_no_right.h => quantum/encoder/tests/config_mock_split_no_right.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/config_mock_split_role.h => quantum/encoder/tests/config_mock_split_role.h +2 -1
@@ 1,6 1,7 @@
-// Copyright 2022 Nick Brassel (@tzarc)
+// Copyright 2022-2023 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
+#include "config_encoder_common.h"
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
M quantum/encoder/tests/encoder_tests.cpp => quantum/encoder/tests/encoder_tests.cpp +1 -1
@@ 41,7 41,7 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderTest : public ::testing::Test {};
M quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp => quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp +74 -17
@@ 33,22 33,29 @@ struct update {
uint8_t updates_array_idx = 0;
update updates[32];
+bool isMaster;
bool isLeftHand;
+extern "C" {
+bool is_keyboard_master(void) {
+ return isMaster;
+}
+
bool encoder_update_kb(uint8_t index, bool clockwise) {
- if (!isLeftHand) {
+ if (!is_keyboard_master()) {
// this method has no effect on slave half
- printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");
+ printf("ignoring update on slave (%d,%s)\n", index, clockwise ? "CW" : "CC");
return true;
}
updates[updates_array_idx % 32] = {index, clockwise};
updates_array_idx++;
return true;
}
+};
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderSplitTestLeftEqRight : public ::testing::Test {
@@ 63,6 70,7 @@ class EncoderSplitTestLeftEqRight : public ::testing::Test {
};
TEST_F(EncoderSplitTestLeftEqRight, TestInitLeft) {
+ isMaster = true;
isLeftHand = true;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true);
@@ 77,6 85,7 @@ TEST_F(EncoderSplitTestLeftEqRight, TestInitLeft) {
}
TEST_F(EncoderSplitTestLeftEqRight, TestInitRight) {
+ isMaster = true;
isLeftHand = false;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], false);
@@ 90,7 99,8 @@ TEST_F(EncoderSplitTestLeftEqRight, TestInitRight) {
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
-TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseLeft) {
+TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseLeftMaster) {
+ isMaster = true;
isLeftHand = true;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 102,9 112,19 @@ TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseLeft) {
EXPECT_EQ(updates_array_idx, 1); // one update received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
+
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseRightSent) {
+TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseRightMaster) {
+ isMaster = true;
isLeftHand = false;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 113,23 133,60 @@ TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseRightSent) {
setAndRead(6, true);
setAndRead(7, true);
- uint8_t slave_state[32] = {0};
- encoder_state_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 1); // one update received
+ EXPECT_EQ(updates[0].index, 3);
+ EXPECT_EQ(updates[0].clockwise, true);
- EXPECT_EQ(slave_state[0], 0);
- EXPECT_EQ(slave_state[1], 0xFF);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestLeftEqRight, TestMultipleEncodersRightReceived) {
+TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseLeftSlave) {
+ isMaster = false;
isLeftHand = true;
encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(0, false);
+ setAndRead(1, false);
+ setAndRead(0, true);
+ setAndRead(1, true);
- uint8_t slave_state[32] = {1, 0xFF}; // First right encoder is CCW, Second right encoder CW
- encoder_update_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
- EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side
- EXPECT_EQ(updates[0].index, 2);
- EXPECT_EQ(updates[0].clockwise, false);
- EXPECT_EQ(updates[1].index, 3);
- EXPECT_EQ(updates[1].clockwise, true);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
+}
+
+TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseRightSlave) {
+ isMaster = false;
+ isLeftHand = false;
+ encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(6, false);
+ setAndRead(7, false);
+ setAndRead(6, true);
+ setAndRead(7, true);
+
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
+
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
}
M quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp => quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp +72 -17
@@ 33,22 33,29 @@ struct update {
uint8_t updates_array_idx = 0;
update updates[32];
+bool isMaster;
bool isLeftHand;
+extern "C" {
+bool is_keyboard_master(void) {
+ return isMaster;
+}
+
bool encoder_update_kb(uint8_t index, bool clockwise) {
- if (!isLeftHand) {
+ if (!is_keyboard_master()) {
// this method has no effect on slave half
- printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");
+ printf("ignoring update on slave (%d,%s)\n", index, clockwise ? "CW" : "CC");
return true;
}
updates[updates_array_idx % 32] = {index, clockwise};
updates_array_idx++;
return true;
}
+};
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderSplitTestLeftGreaterThanRight : public ::testing::Test {
@@ 94,7 101,8 @@ TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitRight) {
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
-TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeft) {
+TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeftMaster) {
+ isMaster = true;
isLeftHand = true;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 106,9 114,19 @@ TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeft) {
EXPECT_EQ(updates_array_idx, 1); // one update received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
+
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightSent) {
+TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightMaster) {
+ isMaster = true;
isLeftHand = false;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 117,23 135,60 @@ TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightSent) {
setAndRead(6, true);
setAndRead(7, true);
- uint8_t slave_state[32] = {0};
- encoder_state_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 1); // one update received
+ EXPECT_EQ(updates[0].index, 3);
+ EXPECT_EQ(updates[0].clockwise, true);
- EXPECT_EQ(slave_state[0], 0xFF);
- EXPECT_EQ(slave_state[1], 0);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestLeftGreaterThanRight, TestMultipleEncodersRightReceived) {
+TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeftSlave) {
+ isMaster = false;
isLeftHand = true;
encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(0, false);
+ setAndRead(1, false);
+ setAndRead(0, true);
+ setAndRead(1, true);
- uint8_t slave_state[32] = {1, 0xFF}; // First right encoder is CCW, Second right encoder no change, third right encoder CW
- encoder_update_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
- EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side
- EXPECT_EQ(updates[0].index, 3);
- EXPECT_EQ(updates[0].clockwise, false);
- EXPECT_EQ(updates[1].index, 4);
- EXPECT_EQ(updates[1].clockwise, true);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
+}
+
+TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightSlave) {
+ isMaster = false;
+ isLeftHand = false;
+ encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(6, false);
+ setAndRead(7, false);
+ setAndRead(6, true);
+ setAndRead(7, true);
+
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
+
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
}
M quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp => quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp +72 -17
@@ 33,22 33,29 @@ struct update {
uint8_t updates_array_idx = 0;
update updates[32];
+bool isMaster;
bool isLeftHand;
+extern "C" {
+bool is_keyboard_master(void) {
+ return isMaster;
+}
+
bool encoder_update_kb(uint8_t index, bool clockwise) {
- if (!isLeftHand) {
+ if (!is_keyboard_master()) {
// this method has no effect on slave half
- printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");
+ printf("ignoring update on slave (%d,%s)\n", index, clockwise ? "CW" : "CC");
return true;
}
updates[updates_array_idx % 32] = {index, clockwise};
updates_array_idx++;
return true;
}
+};
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderSplitTestLeftLessThanRight : public ::testing::Test {
@@ 94,7 101,8 @@ TEST_F(EncoderSplitTestLeftLessThanRight, TestInitRight) {
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
-TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseLeft) {
+TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseLeftMaster) {
+ isMaster = true;
isLeftHand = true;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 106,9 114,19 @@ TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseLeft) {
EXPECT_EQ(updates_array_idx, 1); // one update received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
+
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseRightSent) {
+TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseRightMaster) {
+ isMaster = true;
isLeftHand = false;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 117,23 135,60 @@ TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseRightSent) {
setAndRead(6, true);
setAndRead(7, true);
- uint8_t slave_state[32] = {0};
- encoder_state_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 1); // one update received
+ EXPECT_EQ(updates[0].index, 3);
+ EXPECT_EQ(updates[0].clockwise, true);
- EXPECT_EQ(slave_state[0], 0);
- EXPECT_EQ(slave_state[1], 0xFF);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestLeftLessThanRight, TestMultipleEncodersRightReceived) {
+TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseLeftSlave) {
+ isMaster = false;
isLeftHand = true;
encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(0, false);
+ setAndRead(1, false);
+ setAndRead(0, true);
+ setAndRead(1, true);
- uint8_t slave_state[32] = {1, 0, 0xFF}; // First right encoder is CCW, Second right encoder no change, third right encoder CW
- encoder_update_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
- EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side
- EXPECT_EQ(updates[0].index, 2);
- EXPECT_EQ(updates[0].clockwise, false);
- EXPECT_EQ(updates[1].index, 4);
- EXPECT_EQ(updates[1].clockwise, true);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
+}
+
+TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseRightSlave) {
+ isMaster = false;
+ isLeftHand = false;
+ encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(6, false);
+ setAndRead(7, false);
+ setAndRead(6, true);
+ setAndRead(7, true);
+
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
+
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
}
M quantum/encoder/tests/encoder_tests_split_no_left.cpp => quantum/encoder/tests/encoder_tests_split_no_left.cpp +40 -29
@@ 33,22 33,29 @@ struct update {
uint8_t updates_array_idx = 0;
update updates[32];
+bool isMaster;
bool isLeftHand;
+extern "C" {
+bool is_keyboard_master(void) {
+ return isMaster;
+}
+
bool encoder_update_kb(uint8_t index, bool clockwise) {
- if (!isLeftHand) {
+ if (!is_keyboard_master()) {
// this method has no effect on slave half
- printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");
+ printf("ignoring update on slave (%d,%s)\n", index, clockwise ? "CW" : "CC");
return true;
}
updates[updates_array_idx % 32] = {index, clockwise};
updates_array_idx++;
return true;
}
+};
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderSplitTestNoLeft : public ::testing::Test {
@@ 82,19 89,8 @@ TEST_F(EncoderSplitTestNoLeft, TestInitRight) {
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
-TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseLeft) {
- isLeftHand = true;
- encoder_init();
- // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
- setAndRead(0, false);
- setAndRead(1, false);
- setAndRead(0, true);
- setAndRead(1, true);
-
- EXPECT_EQ(updates_array_idx, 0); // no updates received
-}
-
-TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseRightSent) {
+TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseLeftMaster) {
+ isMaster = true;
isLeftHand = false;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@@ 103,23 99,38 @@ TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseRightSent) {
setAndRead(2, true);
setAndRead(3, true);
- uint8_t slave_state[32] = {0};
- encoder_state_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 1); // one update received
+ EXPECT_EQ(updates[0].index, 1);
+ EXPECT_EQ(updates[0].clockwise, true);
- EXPECT_EQ(slave_state[0], 0);
- EXPECT_EQ(slave_state[1], 0xFF);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestNoLeft, TestMultipleEncodersRightReceived) {
- isLeftHand = true;
+TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseRightSlave) {
+ isMaster = false;
+ isLeftHand = false;
encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(2, false);
+ setAndRead(3, false);
+ setAndRead(2, true);
+ setAndRead(3, true);
- uint8_t slave_state[32] = {1, 0xFF}; // First right encoder is CCW, Second right encoder no change, third right encoder CW
- encoder_update_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
- EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side
- EXPECT_EQ(updates[0].index, 0);
- EXPECT_EQ(updates[0].clockwise, false);
- EXPECT_EQ(updates[1].index, 1);
- EXPECT_EQ(updates[1].clockwise, true);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
}
M quantum/encoder/tests/encoder_tests_split_no_right.cpp => quantum/encoder/tests/encoder_tests_split_no_right.cpp +42 -24
@@ 33,22 33,29 @@ struct update {
uint8_t updates_array_idx = 0;
update updates[32];
+bool isMaster;
bool isLeftHand;
+extern "C" {
+bool is_keyboard_master(void) {
+ return isMaster;
+}
+
bool encoder_update_kb(uint8_t index, bool clockwise) {
- if (!isLeftHand) {
+ if (!is_keyboard_master()) {
// this method has no effect on slave half
- printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");
+ printf("ignoring update on slave (%d,%s)\n", index, clockwise ? "CW" : "CC");
return true;
}
updates[updates_array_idx % 32] = {index, clockwise};
updates_array_idx++;
return true;
}
+};
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderSplitTestNoRight : public ::testing::Test {
@@ 82,37 89,48 @@ TEST_F(EncoderSplitTestNoRight, TestInitRight) {
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
-TEST_F(EncoderSplitTestNoRight, TestOneClockwiseLeft) {
+TEST_F(EncoderSplitTestNoRight, TestOneClockwiseLeftMaster) {
+ isMaster = true;
isLeftHand = true;
encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update.
- setAndRead(0, false);
- setAndRead(1, false);
- setAndRead(0, true);
- setAndRead(1, true);
+ setAndRead(2, false);
+ setAndRead(3, false);
+ setAndRead(2, true);
+ setAndRead(3, true);
- EXPECT_EQ(updates_array_idx, 1); // one updates received
- EXPECT_EQ(updates[0].index, 0);
+ EXPECT_EQ(updates_array_idx, 1); // one update received
+ EXPECT_EQ(updates[0].index, 1);
EXPECT_EQ(updates[0].clockwise, true);
-}
-TEST_F(EncoderSplitTestNoRight, TestOneClockwiseRightSent) {
- isLeftHand = false;
- encoder_init();
-
- uint8_t slave_state[32] = {0xAA, 0xAA};
- encoder_state_raw(slave_state);
-
- EXPECT_EQ(slave_state[0], 0xAA);
- EXPECT_EQ(slave_state[1], 0xAA);
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 0); // No events should be queued on master
}
-TEST_F(EncoderSplitTestNoRight, TestMultipleEncodersRightReceived) {
+TEST_F(EncoderSplitTestNoRight, TestOneClockwiseRightSlave) {
+ isMaster = false;
isLeftHand = true;
encoder_init();
+ // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
+ setAndRead(2, false);
+ setAndRead(3, false);
+ setAndRead(2, true);
+ setAndRead(3, true);
- uint8_t slave_state[32] = {1, 0xFF}; // These values would trigger updates if there were encoders on the other side
- encoder_update_raw(slave_state);
+ EXPECT_EQ(updates_array_idx, 0); // no updates received
- EXPECT_EQ(updates_array_idx, 0); // no updates received -- no right-hand encoders
+ int events_queued = 0;
+ encoder_events_t events;
+ encoder_retrieve_events(&events);
+ while (events.tail != events.head) {
+ events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
+ ++events_queued;
+ }
+ EXPECT_EQ(events_queued, 1); // One event should be queued on slave
}
M quantum/encoder/tests/encoder_tests_split_role.cpp => quantum/encoder/tests/encoder_tests_split_role.cpp +1 -7
@@ 50,7 50,7 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
bool setAndRead(pin_t pin, bool val) {
setPin(pin, val);
- return encoder_read();
+ return encoder_task();
}
class EncoderSplitTestRole : public ::testing::Test {
@@ 87,9 87,6 @@ TEST_F(EncoderSplitTestRole, TestPrimaryRight) {
setAndRead(6, true);
setAndRead(7, true);
- uint8_t slave_state[32] = {0};
- encoder_state_raw(slave_state);
-
EXPECT_EQ(num_updates, 1); // one update received
}
@@ 116,8 113,5 @@ TEST_F(EncoderSplitTestRole, TestNotPrimaryRight) {
setAndRead(6, true);
setAndRead(7, true);
- uint8_t slave_state[32] = {0};
- encoder_state_raw(slave_state);
-
EXPECT_EQ(num_updates, 0); // zero updates received
}
M quantum/encoder/tests/mock_split.c => quantum/encoder/tests/mock_split.c +0 -4
@@ 36,7 36,3 @@ bool setPin(pin_t pin, bool val) {
}
void last_encoder_activity_trigger(void) {}
-
-__attribute__((weak)) bool is_keyboard_master(void) {
- return true;
-}
M quantum/encoder/tests/mock_split.h => quantum/encoder/tests/mock_split.h +0 -3
@@ 22,9 22,6 @@
#define SPLIT_KEYBOARD
typedef uint8_t pin_t;
-void encoder_state_raw(uint8_t* slave_state);
-void encoder_update_raw(uint8_t* slave_state);
-
extern bool pins[];
extern bool pinIsInputHigh[];
M quantum/encoder/tests/rules.mk => quantum/encoder/tests/rules.mk +7 -0
@@ 3,6 3,7 @@ encoder_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock.h
encoder_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests.cpp \
$(QUANTUM_PATH)/encoder.c
@@ 13,6 14,7 @@ encoder_split_left_eq_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_
encoder_split_left_eq_right_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_eq_right.cpp \
$(QUANTUM_PATH)/encoder.c
@@ 23,6 25,7 @@ encoder_split_left_gt_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_
encoder_split_left_gt_right_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_gt_right.cpp \
$(QUANTUM_PATH)/encoder.c
@@ 33,6 36,7 @@ encoder_split_left_lt_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_
encoder_split_left_lt_right_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_lt_right.cpp \
$(QUANTUM_PATH)/encoder.c
@@ 43,6 47,7 @@ encoder_split_no_left_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_
encoder_split_no_left_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_no_left.cpp \
$(QUANTUM_PATH)/encoder.c
@@ 53,6 58,7 @@ encoder_split_no_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split
encoder_split_no_right_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_no_right.cpp \
$(QUANTUM_PATH)/encoder.c
@@ 63,6 69,7 @@ encoder_split_role_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_rol
encoder_split_role_SRC := \
platforms/test/timer.c \
+ drivers/encoder/encoder_quadrature.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_role.cpp \
$(QUANTUM_PATH)/encoder.c
M quantum/keyboard.c => quantum/keyboard.c +1 -1
@@ 689,7 689,7 @@ void keyboard_task(void) {
#endif
#ifdef ENCODER_ENABLE
- if (encoder_read()) {
+ if (encoder_task()) {
last_encoder_activity_trigger();
activity_has_occurred = true;
}
M quantum/split_common/transaction_id_define.h => quantum/split_common/transaction_id_define.h +1 -0
@@ 31,6 31,7 @@ enum serial_transaction_id {
#ifdef ENCODER_ENABLE
GET_ENCODERS_CHECKSUM,
GET_ENCODERS_DATA,
+ PUT_ENCODER_TAIL,
#endif // ENCODER_ENABLE
#ifndef DISABLE_SYNC_TIMER
M quantum/split_common/transactions.c => quantum/split_common/transactions.c +17 -9
@@ 234,21 234,28 @@ static void master_matrix_handlers_slave(matrix_row_t master_matrix[], matrix_ro
#ifdef ENCODER_ENABLE
static bool encoder_handlers_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
- static uint32_t last_update = 0;
- uint8_t temp_state[NUM_ENCODERS_MAX_PER_SIDE];
+ static uint32_t last_update = 0;
+ encoder_events_t temp_events;
- bool okay = read_if_checksum_mismatch(GET_ENCODERS_CHECKSUM, GET_ENCODERS_DATA, &last_update, temp_state, split_shmem->encoders.state, sizeof(temp_state));
- if (okay) encoder_update_raw(temp_state);
+ bool okay = read_if_checksum_mismatch(GET_ENCODERS_CHECKSUM, GET_ENCODERS_DATA, &last_update, &temp_events, &split_shmem->encoders.events, sizeof(temp_events));
+ if (okay) {
+ encoder_handle_slave_events(&split_shmem->encoders.events);
+ transport_write(PUT_ENCODER_TAIL, &split_shmem->encoders.events.tail, sizeof(split_shmem->encoders.events.tail));
+ split_shmem->encoders.checksum = crc8(&split_shmem->encoders.events, sizeof(split_shmem->encoders.events));
+ }
return okay;
}
static void encoder_handlers_slave(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
- uint8_t encoder_state[NUM_ENCODERS_MAX_PER_SIDE];
- encoder_state_raw(encoder_state);
// Always prepare the encoder state for read.
- memcpy(split_shmem->encoders.state, encoder_state, sizeof(encoder_state));
+ encoder_retrieve_events(&split_shmem->encoders.events);
// Now update the checksum given that the encoders has been written to
- split_shmem->encoders.checksum = crc8(encoder_state, sizeof(encoder_state));
+ split_shmem->encoders.checksum = crc8(&split_shmem->encoders.events, sizeof(split_shmem->encoders.events));
+}
+
+static void encoder_handlers_slave_reset(uint8_t initiator2target_buffer_size, const void *initiator2target_buffer, uint8_t target2initiator_buffer_size, void *target2initiator_buffer) {
+ uint8_t tail_index = *(uint8_t *)initiator2target_buffer;
+ encoder_set_tail_index(tail_index);
}
// clang-format off
@@ 256,7 263,8 @@ static void encoder_handlers_slave(matrix_row_t master_matrix[], matrix_row_t sl
# define TRANSACTIONS_ENCODERS_SLAVE() TRANSACTION_HANDLER_SLAVE_AUTOLOCK(encoder)
# define TRANSACTIONS_ENCODERS_REGISTRATIONS \
[GET_ENCODERS_CHECKSUM] = trans_target2initiator_initializer(encoders.checksum), \
- [GET_ENCODERS_DATA] = trans_target2initiator_initializer(encoders.state),
+ [GET_ENCODERS_DATA] = trans_target2initiator_initializer(encoders.events), \
+ [PUT_ENCODER_TAIL] = trans_initiator2target_initializer_cb(encoders.events.tail, encoder_handlers_slave_reset),
// clang-format on
#else // ENCODER_ENABLE
M quantum/split_common/transport.h => quantum/split_common/transport.h +2 -2
@@ 65,8 65,8 @@ typedef struct _split_master_matrix_sync_t {
#ifdef ENCODER_ENABLE
typedef struct _split_slave_encoder_sync_t {
- uint8_t checksum;
- uint8_t state[NUM_ENCODERS_MAX_PER_SIDE];
+ uint8_t checksum;
+ encoder_events_t events;
} split_slave_encoder_sync_t;
#endif // ENCODER_ENABLE