hailey
/
qmk_firmware
mirror of https://github.com/hailey/qmk_firmware.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Asymmetric encoders, encoder tests. (#16068)

Browse Source
zvecr-patch-1
Nick Brassel 3 years ago committed by GitHub
parent 2218690d0b
commit 2f6751e48a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 921 additions and 138 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      builddefs/build_test.mk
  2. 1
      builddefs/testlist.mk
  3. 13
      docs/feature_encoders.md
  4. 3
      keyboards/draculad/config.h
  5. 11
      keyboards/sofle/keyhive/config.h
  6. 4
      keyboards/viktus/sp_mini/config.h
  7. 114
      quantum/encoder.c
  8. 28
      quantum/encoder.h
  9. 22
      quantum/encoder/tests/config_mock.h
  10. 26
      quantum/encoder/tests/config_mock_split_left_eq_right.h
  11. 26
      quantum/encoder/tests/config_mock_split_left_gt_right.h
  12. 26
      quantum/encoder/tests/config_mock_split_left_lt_right.h
  13. 26
      quantum/encoder/tests/config_mock_split_no_left.h
  14. 26
      quantum/encoder/tests/config_mock_split_no_right.h
  15. 36
      quantum/encoder/tests/encoder_tests.cpp
  16. 135
      quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp
  17. 139
      quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp
  18. 139
      quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp
  19. 68
      quantum/encoder/tests/encoder_tests_split_no_left.cpp
  20. 118
      quantum/encoder/tests/encoder_tests_split_no_right.cpp
  21. 6
      quantum/encoder/tests/mock.h
  22. 16
      quantum/encoder/tests/mock_split.h
  23. 53
      quantum/encoder/tests/rules.mk
  24. 6
      quantum/encoder/tests/testlist.mk
  25. 4
      quantum/split_common/transactions.c
  26. 3
      quantum/split_common/transport.h
  27. 8
      quantum/util.h

2
builddefs/build_test.mk
Unescape View File

@ -4,6 +4,8 @@ endif
.DEFAULT_GOAL := all .DEFAULT_GOAL := all
OPT = g
include paths.mk include paths.mk
include $(BUILDDEFS_PATH)/message.mk include $(BUILDDEFS_PATH)/message.mk

1
builddefs/testlist.mk
Unescape View File

@ -2,6 +2,7 @@ TEST_LIST = $(sort $(patsubst %/test.mk,%, $(shell find $(ROOT_DIR)tests -type f
FULL_TESTS := $(notdir $(TEST_LIST)) FULL_TESTS := $(notdir $(TEST_LIST))
include $(QUANTUM_PATH)/debounce/tests/testlist.mk include $(QUANTUM_PATH)/debounce/tests/testlist.mk
include $(QUANTUM_PATH)/encoder/tests/testlist.mk
include $(QUANTUM_PATH)/sequencer/tests/testlist.mk include $(QUANTUM_PATH)/sequencer/tests/testlist.mk
include $(PLATFORM_PATH)/test/testlist.mk include $(PLATFORM_PATH)/test/testlist.mk

13
docs/feature_encoders.md
Unescape View File

@ -54,6 +54,19 @@ If you are using different pinouts for the encoders on each half of a split keyb
#define ENCODER_RESOLUTIONS_RIGHT { 2, 4 } #define ENCODER_RESOLUTIONS_RIGHT { 2, 4 }
``` ```
If the `_RIGHT` definitions aren't specified in your `config.h`, then the non-`_RIGHT` versions will be applied to both sides of the split.
Additionally, if one side does not have an encoder, you can specify `{}` for the pins/resolution -- for example, a split keyboard with only a right-side encoder:
```c
#define ENCODERS_PAD_A { }
#define ENCODERS_PAD_B { }
#define ENCODER_RESOLUTIONS { }
#define ENCODERS_PAD_A_RIGHT { B12 }
#define ENCODERS_PAD_B_RIGHT { B13 }
#define ENCODER_RESOLUTIONS_RIGHT { 4 }
```
## Callbacks ## Callbacks
The callback functions can be inserted into your `<keyboard>.c`: The callback functions can be inserted into your `<keyboard>.c`:

3
keyboards/draculad/config.h
Unescape View File

@ -61,7 +61,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define ENCODERS_PAD_A {B2 , B4} #define ENCODERS_PAD_A {B2 , B4}
#define ENCODERS_PAD_B {B6 , B5} #define ENCODERS_PAD_B {B6 , B5}
#define ENCODER_RESOLUTIONS { 4, 4, 4, 1} #define ENCODER_RESOLUTIONS { 4, 4 }
#define ENCODER_RESOLUTIONS_RIGHT { 4, 1 }
#define UNUSED_PINS #define UNUSED_PINS
#define EE_HANDS #define EE_HANDS

11
keyboards/sofle/keyhive/config.h
Unescape View File

@ -42,11 +42,12 @@
#define DEBOUNCE 5 #define DEBOUNCE 5
// Encoder support // Encoder support
#define ENCODERS_PAD_A { F5 } #define ENCODERS_PAD_A { F5 }
#define ENCODERS_PAD_B { F4 } #define ENCODERS_PAD_B { F4 }
#define ENCODERS_PAD_A_RIGHT { F4 } #define ENCODERS_PAD_A_RIGHT { F4 }
#define ENCODERS_PAD_B_RIGHT { F5 } #define ENCODERS_PAD_B_RIGHT { F5 }
#define ENCODER_RESOLUTIONS { 4, 2 } // Left encoder seems to have double-output issue but right does not. #define ENCODER_RESOLUTIONS { 4 }
#define ENCODER_RESOLUTIONS_RIGHT { 2 } // Left encoder seems to have double-output issue but right does not.
#define TAP_CODE_DELAY 10 #define TAP_CODE_DELAY 10

4
keyboards/viktus/sp_mini/config.h
Unescape View File

@ -35,7 +35,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// wiring of each half // wiring of each half
#define MATRIX_ROW_PINS { F0, B5, B4, D7, D6 } #define MATRIX_ROW_PINS { F0, B5, B4, D7, D6 }
#define MATRIX_COL_PINS { B6, C6, C7, D4, D2, D3, D5 } // no B7 on left hand #define MATRIX_COL_PINS { B6, C6, C7, D4, D2, D3, D5, NO_PIN } // no B7 on left hand
#define MATRIX_ROW_PINS_RIGHT { F0, B5, B4, D7, D6 } #define MATRIX_ROW_PINS_RIGHT { F0, B5, B4, D7, D6 }
#define MATRIX_COL_PINS_RIGHT { B6, C6, C7, D4, D2, D3, D5, B7 } #define MATRIX_COL_PINS_RIGHT { B6, C6, C7, D4, D2, D3, D5, B7 }
@ -78,7 +78,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define ENCODERS_PAD_A_RIGHT {F4} //#define ENCODERS_PAD_A_RIGHT {F4}
//#define ENCODERS_PAD_B_RIGHT {F1} //#define ENCODERS_PAD_B_RIGHT {F1}
#define ENCODER_RESOLUTIONS { 8, 8 } #define ENCODER_RESOLUTIONS { 8 }
/* /*
* Feature disable options * Feature disable options

114
quantum/encoder.c
Unescape View File

@ -31,11 +31,13 @@
# error "No encoder pads defined by ENCODERS_PAD_A and ENCODERS_PAD_B" # error "No encoder pads defined by ENCODERS_PAD_A and ENCODERS_PAD_B"
#endif #endif
#define NUMBER_OF_ENCODERS (sizeof(encoders_pad_a) / sizeof(pin_t)) extern volatile bool isLeftHand;
static pin_t encoders_pad_a[] = ENCODERS_PAD_A;
static pin_t encoders_pad_b[] = ENCODERS_PAD_B; 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_RESOLUTIONS #ifdef ENCODER_RESOLUTIONS
static uint8_t encoder_resolutions[] = ENCODER_RESOLUTIONS; static uint8_t encoder_resolutions[NUM_ENCODERS] = ENCODER_RESOLUTIONS;
#endif #endif
#ifndef ENCODER_DIRECTION_FLIP #ifndef ENCODER_DIRECTION_FLIP
@ -47,18 +49,20 @@ static uint8_t encoder_resolutions[] = ENCODER_RESOLUTIONS;
#endif #endif
static int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0}; 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[NUMBER_OF_ENCODERS] = {0}; static uint8_t encoder_state[NUM_ENCODERS] = {0};
static int8_t encoder_pulses[NUMBER_OF_ENCODERS] = {0}; static int8_t encoder_pulses[NUM_ENCODERS] = {0};
// encoder counts
static uint8_t thisCount;
#ifdef SPLIT_KEYBOARD #ifdef SPLIT_KEYBOARD
// right half encoders come over as second set of encoders // encoder offsets for each hand
static uint8_t encoder_value[NUMBER_OF_ENCODERS * 2] = {0};
// row offsets for each hand
static uint8_t thisHand, thatHand; static uint8_t thisHand, thatHand;
#else // encoder counts for each hand
static uint8_t encoder_value[NUMBER_OF_ENCODERS] = {0}; static uint8_t thatCount;
#endif #endif
static uint8_t encoder_value[NUM_ENCODERS] = {0};
__attribute__((weak)) void encoder_wait_pullup_charge(void) { __attribute__((weak)) void encoder_wait_pullup_charge(void) {
wait_us(100); wait_us(100);
} }
@ -72,36 +76,63 @@ __attribute__((weak)) bool encoder_update_kb(uint8_t index, bool clockwise) {
} }
void encoder_init(void) { 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) #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) { if (!isLeftHand) {
const pin_t encoders_pad_a_right[] = ENCODERS_PAD_A_RIGHT; static const pin_t encoders_pad_a_right[] = ENCODERS_PAD_A_RIGHT;
const pin_t encoders_pad_b_right[] = ENCODERS_PAD_B_RIGHT; static const pin_t encoders_pad_b_right[] = ENCODERS_PAD_B_RIGHT;
# if defined(ENCODER_RESOLUTIONS_RIGHT) for (uint8_t i = 0; i < thisCount; i++) {
const uint8_t encoder_resolutions_right[] = ENCODER_RESOLUTIONS_RIGHT;
# endif
for (uint8_t i = 0; i < NUMBER_OF_ENCODERS; i++) {
encoders_pad_a[i] = encoders_pad_a_right[i]; encoders_pad_a[i] = encoders_pad_a_right[i];
encoders_pad_b[i] = encoders_pad_b_right[i]; encoders_pad_b[i] = encoders_pad_b_right[i];
# if defined(ENCODER_RESOLUTIONS_RIGHT)
encoder_resolutions[i] = encoder_resolutions_right[i];
# endif
} }
} }
#endif #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 (int i = 0; i < NUMBER_OF_ENCODERS; i++) { for (uint8_t i = 0; i < thisCount; i++) {
setPinInputHigh(encoders_pad_a[i]); setPinInputHigh(encoders_pad_a[i]);
setPinInputHigh(encoders_pad_b[i]); setPinInputHigh(encoders_pad_b[i]);
} }
encoder_wait_pullup_charge(); encoder_wait_pullup_charge();
for (int i = 0; i < NUMBER_OF_ENCODERS; i++) { for (uint8_t i = 0; i < thisCount; i++) {
encoder_state[i] = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1); encoder_state[i] = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
} }
#ifdef SPLIT_KEYBOARD
thisHand = isLeftHand ? 0 : NUMBER_OF_ENCODERS;
thatHand = NUMBER_OF_ENCODERS - thisHand;
#endif
} }
static bool encoder_update(uint8_t index, uint8_t state) { static bool encoder_update(uint8_t index, uint8_t state) {
@ -109,9 +140,9 @@ static bool encoder_update(uint8_t index, uint8_t state) {
uint8_t i = index; uint8_t i = index;
#ifdef ENCODER_RESOLUTIONS #ifdef ENCODER_RESOLUTIONS
uint8_t resolution = encoder_resolutions[i]; const uint8_t resolution = encoder_resolutions[i];
#else #else
uint8_t resolution = ENCODER_RESOLUTION; const uint8_t resolution = ENCODER_RESOLUTION;
#endif #endif
#ifdef SPLIT_KEYBOARD #ifdef SPLIT_KEYBOARD
@ -139,10 +170,13 @@ static bool encoder_update(uint8_t index, uint8_t state) {
bool encoder_read(void) { bool encoder_read(void) {
bool changed = false; bool changed = false;
for (uint8_t i = 0; i < NUMBER_OF_ENCODERS; i++) { for (uint8_t i = 0; i < thisCount; i++) {
encoder_state[i] <<= 2; uint8_t new_status = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
encoder_state[i] |= (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1); if ((encoder_state[i] & 0x3) != new_status) {
changed |= encoder_update(i, encoder_state[i]); encoder_state[i] <<= 2;
encoder_state[i] |= new_status;
changed |= encoder_update(i, encoder_state[i]);
}
} }
return changed; return changed;
} }
@ -150,15 +184,15 @@ bool encoder_read(void) {
#ifdef SPLIT_KEYBOARD #ifdef SPLIT_KEYBOARD
void last_encoder_activity_trigger(void); void last_encoder_activity_trigger(void);
void encoder_state_raw(uint8_t* slave_state) { void encoder_state_raw(uint8_t *slave_state) {
memcpy(slave_state, &encoder_value[thisHand], sizeof(uint8_t) * NUMBER_OF_ENCODERS); memcpy(slave_state, &encoder_value[thisHand], sizeof(uint8_t) * thisCount);
} }
void encoder_update_raw(uint8_t* slave_state) { void encoder_update_raw(uint8_t *slave_state) {
bool changed = false; bool changed = false;
for (uint8_t i = 0; i < NUMBER_OF_ENCODERS; i++) { for (uint8_t i = 0; i < thatCount; i++) { // Note inverted logic -- we want the opposite side
uint8_t index = i + thatHand; const uint8_t index = i + thatHand;
int8_t delta = slave_state[i] - encoder_value[index]; int8_t delta = slave_state[i] - encoder_value[index];
while (delta > 0) { while (delta > 0) {
delta--; delta--;
encoder_value[index]++; encoder_value[index]++;

28
quantum/encoder.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "quantum.h" #include "quantum.h"
#include "util.h"
void encoder_init(void); void encoder_init(void);
bool encoder_read(void); bool encoder_read(void);
@ -26,6 +27,31 @@ bool encoder_update_kb(uint8_t index, bool clockwise);
bool encoder_update_user(uint8_t index, bool clockwise); bool encoder_update_user(uint8_t index, bool clockwise);
#ifdef SPLIT_KEYBOARD #ifdef SPLIT_KEYBOARD
void encoder_state_raw(uint8_t* slave_state); void encoder_state_raw(uint8_t* slave_state);
void encoder_update_raw(uint8_t* slave_state); void encoder_update_raw(uint8_t* slave_state);
#endif
# if defined(ENCODERS_PAD_A_RIGHT)
# define NUM_ENCODERS_LEFT (sizeof(((pin_t[])ENCODERS_PAD_A)) / sizeof(pin_t))
# define NUM_ENCODERS_RIGHT (sizeof(((pin_t[])ENCODERS_PAD_A_RIGHT)) / sizeof(pin_t))
# else
# define NUM_ENCODERS_LEFT (sizeof(((pin_t[])ENCODERS_PAD_A)) / sizeof(pin_t))
# define NUM_ENCODERS_RIGHT NUM_ENCODERS_LEFT
# endif
# define NUM_ENCODERS (NUM_ENCODERS_LEFT + NUM_ENCODERS_RIGHT)
#else // SPLIT_KEYBOARD
# define NUM_ENCODERS (sizeof(((pin_t[])ENCODERS_PAD_A)) / sizeof(pin_t))
# define NUM_ENCODERS_LEFT NUM_ENCODERS
# define NUM_ENCODERS_RIGHT 0
#endif // 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_MAX_PER_SIDE MAX(NUM_ENCODERS_LEFT, NUM_ENCODERS_RIGHT)

22
quantum/encoder/tests/config_mock.h
Unescape View File

@ -0,0 +1,22 @@
// Copyright 2022 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0 }
#define ENCODERS_PAD_B \
{ 1 }
#ifdef __cplusplus
extern "C" {
#endif
#include "mock.h"
#ifdef __cplusplus
};
#endif

26
quantum/encoder/tests/config_mock_split_left_eq_right.h
Unescape View File

@ -0,0 +1,26 @@
// Copyright 2022 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0, 2 }
#define ENCODERS_PAD_B \
{ 1, 3 }
#define ENCODERS_PAD_A_RIGHT \
{ 4, 6 }
#define ENCODERS_PAD_B_RIGHT \
{ 5, 7 }
#ifdef __cplusplus
extern "C" {
#endif
#include "mock_split.h"
#ifdef __cplusplus
};
#endif

26
quantum/encoder/tests/config_mock_split_left_gt_right.h
Unescape View File

@ -0,0 +1,26 @@
// Copyright 2022 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0, 2, 4 }
#define ENCODERS_PAD_B \
{ 1, 3, 5 }
#define ENCODERS_PAD_A_RIGHT \
{ 6, 8 }
#define ENCODERS_PAD_B_RIGHT \
{ 7, 9 }
#ifdef __cplusplus
extern "C" {
#endif
#include "mock_split.h"
#ifdef __cplusplus
};
#endif

26
quantum/encoder/tests/config_mock_split_left_lt_right.h
Unescape View File

@ -0,0 +1,26 @@
// Copyright 2022 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0, 2 }
#define ENCODERS_PAD_B \
{ 1, 3 }
#define ENCODERS_PAD_A_RIGHT \
{ 4, 6, 8 }
#define ENCODERS_PAD_B_RIGHT \
{ 5, 7, 9 }
#ifdef __cplusplus
extern "C" {
#endif
#include "mock_split.h"
#ifdef __cplusplus
};
#endif

26
quantum/encoder/tests/config_mock_split_no_left.h
Unescape View File

@ -0,0 +1,26 @@
// Copyright 2022 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{}
#define ENCODERS_PAD_B \
{}
#define ENCODERS_PAD_A_RIGHT \
{ 0, 2 }
#define ENCODERS_PAD_B_RIGHT \
{ 1, 3 }
#ifdef __cplusplus
extern "C" {
#endif
#include "mock_split.h"
#ifdef __cplusplus
};
#endif

26
quantum/encoder/tests/config_mock_split_no_right.h
Unescape View File

@ -0,0 +1,26 @@
// Copyright 2022 Nick Brassel (@tzarc)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#define MATRIX_ROWS 1
#define MATRIX_COLS 1
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0, 2 }
#define ENCODERS_PAD_B \
{ 1, 3 }
#define ENCODERS_PAD_A_RIGHT \
{}
#define ENCODERS_PAD_B_RIGHT \
{}
#ifdef __cplusplus
extern "C" {
#endif
#include "mock_split.h"
#ifdef __cplusplus
};
#endif

36
quantum/encoder/tests/encoder_tests.cpp
Unescape View File

@ -30,12 +30,12 @@ struct update {
bool clockwise; bool clockwise;
}; };
uint8_t uidx = 0; uint8_t updates_array_idx = 0;
update updates[32]; update updates[32];
bool encoder_update_kb(uint8_t index, bool clockwise) { bool encoder_update_kb(uint8_t index, bool clockwise) {
updates[uidx % 32] = {index, clockwise}; updates[updates_array_idx % 32] = {index, clockwise};
uidx++; updates_array_idx++;
return true; return true;
} }
@ -47,15 +47,15 @@ bool setAndRead(pin_t pin, bool val) {
class EncoderTest : public ::testing::Test {}; class EncoderTest : public ::testing::Test {};
TEST_F(EncoderTest, TestInit) { TEST_F(EncoderTest, TestInit) {
uidx = 0; updates_array_idx = 0;
encoder_init(); encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true); EXPECT_EQ(pinIsInputHigh[0], true);
EXPECT_EQ(pinIsInputHigh[1], true); EXPECT_EQ(pinIsInputHigh[1], true);
EXPECT_EQ(uidx, 0); EXPECT_EQ(updates_array_idx, 0);
} }
TEST_F(EncoderTest, TestOneClockwise) { TEST_F(EncoderTest, TestOneClockwise) {
uidx = 0; updates_array_idx = 0;
encoder_init(); encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update. // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
setAndRead(0, false); setAndRead(0, false);
@ -63,26 +63,26 @@ TEST_F(EncoderTest, TestOneClockwise) {
setAndRead(0, true); setAndRead(0, true);
setAndRead(1, true); setAndRead(1, true);
EXPECT_EQ(uidx, 1); EXPECT_EQ(updates_array_idx, 1);
EXPECT_EQ(updates[0].index, 0); EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true); EXPECT_EQ(updates[0].clockwise, true);
} }
TEST_F(EncoderTest, TestOneCounterClockwise) { TEST_F(EncoderTest, TestOneCounterClockwise) {
uidx = 0; updates_array_idx = 0;
encoder_init(); encoder_init();
setAndRead(1, false); setAndRead(1, false);
setAndRead(0, false); setAndRead(0, false);
setAndRead(1, true); setAndRead(1, true);
setAndRead(0, true); setAndRead(0, true);
EXPECT_EQ(uidx, 1); EXPECT_EQ(updates_array_idx, 1);
EXPECT_EQ(updates[0].index, 0); EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, false); EXPECT_EQ(updates[0].clockwise, false);
} }
TEST_F(EncoderTest, TestTwoClockwiseOneCC) { TEST_F(EncoderTest, TestTwoClockwiseOneCC) {
uidx = 0; updates_array_idx = 0;
encoder_init(); encoder_init();
setAndRead(0, false); setAndRead(0, false);
setAndRead(1, false); setAndRead(1, false);
@ -97,7 +97,7 @@ TEST_F(EncoderTest, TestTwoClockwiseOneCC) {
setAndRead(1, true); setAndRead(1, true);
setAndRead(0, true); setAndRead(0, true);
EXPECT_EQ(uidx, 3); EXPECT_EQ(updates_array_idx, 3);
EXPECT_EQ(updates[0].index, 0); EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true); EXPECT_EQ(updates[0].clockwise, true);
EXPECT_EQ(updates[1].index, 0); EXPECT_EQ(updates[1].index, 0);
@ -107,38 +107,38 @@ TEST_F(EncoderTest, TestTwoClockwiseOneCC) {
} }
TEST_F(EncoderTest, TestNoEarly) { TEST_F(EncoderTest, TestNoEarly) {
uidx = 0; updates_array_idx = 0;
encoder_init(); encoder_init();
// send 3 pulses. with resolution 4, that's not enough for a step. // send 3 pulses. with resolution 4, that's not enough for a step.
setAndRead(0, false); setAndRead(0, false);
setAndRead(1, false); setAndRead(1, false);
setAndRead(0, true); setAndRead(0, true);
EXPECT_EQ(uidx, 0); EXPECT_EQ(updates_array_idx, 0);
// now send last pulse // now send last pulse
setAndRead(1, true); setAndRead(1, true);
EXPECT_EQ(uidx, 1); EXPECT_EQ(updates_array_idx, 1);
EXPECT_EQ(updates[0].index, 0); EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true); EXPECT_EQ(updates[0].clockwise, true);
} }
TEST_F(EncoderTest, TestHalfway) { TEST_F(EncoderTest, TestHalfway) {
uidx = 0; updates_array_idx = 0;
encoder_init(); encoder_init();
// go halfway // go halfway
setAndRead(0, false); setAndRead(0, false);
setAndRead(1, false); setAndRead(1, false);
EXPECT_EQ(uidx, 0); EXPECT_EQ(updates_array_idx, 0);
// back off // back off
setAndRead(1, true); setAndRead(1, true);
setAndRead(0, true); setAndRead(0, true);
EXPECT_EQ(uidx, 0); EXPECT_EQ(updates_array_idx, 0);
// go all the way // go all the way
setAndRead(0, false); setAndRead(0, false);
setAndRead(1, false); setAndRead(1, false);
setAndRead(0, true); setAndRead(0, true);
setAndRead(1, true); setAndRead(1, true);
// should result in 1 update // should result in 1 update
EXPECT_EQ(uidx, 1); EXPECT_EQ(updates_array_idx, 1);
EXPECT_EQ(updates[0].index, 0); EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true); EXPECT_EQ(updates[0].clockwise, true);
} }

135
quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp
Unescape View File

@ -0,0 +1,135 @@
/* Copyright 2021 Balz Guenat
*
* 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/>.
*/
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include <vector>
#include <algorithm>
#include <stdio.h>
extern "C" {
#include "encoder.h"
#include "encoder/tests/mock_split.h"
}
struct update {
int8_t index;
bool clockwise;
};
uint8_t updates_array_idx = 0;
update updates[32];
bool isLeftHand;
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!isLeftHand) {
// this method has no effect on slave half
printf("ignoring update on right hand (%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();
}
class EncoderSplitTestLeftEqRight : public ::testing::Test {
protected:
void SetUp() override {
updates_array_idx = 0;
for (int i = 0; i < 32; i++) {
pinIsInputHigh[i] = 0;
pins[i] = 0;
}
}
};
TEST_F(EncoderSplitTestLeftEqRight, TestInitLeft) {
isLeftHand = true;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true);
EXPECT_EQ(pinIsInputHigh[1], true);
EXPECT_EQ(pinIsInputHigh[2], true);
EXPECT_EQ(pinIsInputHigh[3], true);
EXPECT_EQ(pinIsInputHigh[4], false);
EXPECT_EQ(pinIsInputHigh[5], false);
EXPECT_EQ(pinIsInputHigh[6], false);
EXPECT_EQ(pinIsInputHigh[7], false);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestLeftEqRight, TestInitRight) {
isLeftHand = false;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], false);
EXPECT_EQ(pinIsInputHigh[1], false);
EXPECT_EQ(pinIsInputHigh[2], false);
EXPECT_EQ(pinIsInputHigh[3], false);
EXPECT_EQ(pinIsInputHigh[4], true);
EXPECT_EQ(pinIsInputHigh[5], true);
EXPECT_EQ(pinIsInputHigh[6], true);
EXPECT_EQ(pinIsInputHigh[7], true);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestLeftEqRight, 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, 1); // one update received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
}
TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseRightSent) {
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);
uint8_t slave_state[32] = {0};
encoder_state_raw(slave_state);
EXPECT_EQ(slave_state[0], 0);
EXPECT_EQ(slave_state[1], 0xFF);
}
TEST_F(EncoderSplitTestLeftEqRight, TestMultipleEncodersRightReceived) {
isLeftHand = true;
encoder_init();
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, 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);
}

139
quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp
Unescape View File

@ -0,0 +1,139 @@
/* Copyright 2021 Balz Guenat
*
* 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/>.
*/
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include <vector>
#include <algorithm>
#include <stdio.h>
extern "C" {
#include "encoder.h"
#include "encoder/tests/mock_split.h"
}
struct update {
int8_t index;
bool clockwise;
};
uint8_t updates_array_idx = 0;
update updates[32];
bool isLeftHand;
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!isLeftHand) {
// this method has no effect on slave half
printf("ignoring update on right hand (%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();
}
class EncoderSplitTestLeftGreaterThanRight : public ::testing::Test {
protected:
void SetUp() override {
updates_array_idx = 0;
for (int i = 0; i < 32; i++) {
pinIsInputHigh[i] = 0;
pins[i] = 0;
}
}
};
TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitLeft) {
isLeftHand = true;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true);
EXPECT_EQ(pinIsInputHigh[1], true);
EXPECT_EQ(pinIsInputHigh[2], true);
EXPECT_EQ(pinIsInputHigh[3], true);
EXPECT_EQ(pinIsInputHigh[4], true);
EXPECT_EQ(pinIsInputHigh[5], true);
EXPECT_EQ(pinIsInputHigh[6], false);
EXPECT_EQ(pinIsInputHigh[7], false);
EXPECT_EQ(pinIsInputHigh[8], false);
EXPECT_EQ(pinIsInputHigh[9], false);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitRight) {
isLeftHand = false;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], false);
EXPECT_EQ(pinIsInputHigh[1], false);
EXPECT_EQ(pinIsInputHigh[2], false);
EXPECT_EQ(pinIsInputHigh[3], false);
EXPECT_EQ(pinIsInputHigh[4], false);
EXPECT_EQ(pinIsInputHigh[5], false);
EXPECT_EQ(pinIsInputHigh[6], true);
EXPECT_EQ(pinIsInputHigh[7], true);
EXPECT_EQ(pinIsInputHigh[8], true);
EXPECT_EQ(pinIsInputHigh[9], true);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestLeftGreaterThanRight, 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, 1); // one update received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
}
TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightSent) {
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);
uint8_t slave_state[32] = {0};
encoder_state_raw(slave_state);
EXPECT_EQ(slave_state[0], 0xFF);
EXPECT_EQ(slave_state[1], 0);
}
TEST_F(EncoderSplitTestLeftGreaterThanRight, TestMultipleEncodersRightReceived) {
isLeftHand = true;
encoder_init();
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, 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);
}

139
quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp
Unescape View File

@ -0,0 +1,139 @@
/* Copyright 2021 Balz Guenat
*
* 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/>.
*/
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include <vector>
#include <algorithm>
#include <stdio.h>
extern "C" {
#include "encoder.h"
#include "encoder/tests/mock_split.h"
}
struct update {
int8_t index;
bool clockwise;
};
uint8_t updates_array_idx = 0;
update updates[32];
bool isLeftHand;
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!isLeftHand) {
// this method has no effect on slave half
printf("ignoring update on right hand (%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();
}
class EncoderSplitTestLeftLessThanRight : public ::testing::Test {
protected:
void SetUp() override {
updates_array_idx = 0;
for (int i = 0; i < 32; i++) {
pinIsInputHigh[i] = 0;
pins[i] = 0;
}
}
};
TEST_F(EncoderSplitTestLeftLessThanRight, TestInitLeft) {
isLeftHand = true;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true);
EXPECT_EQ(pinIsInputHigh[1], true);
EXPECT_EQ(pinIsInputHigh[2], true);
EXPECT_EQ(pinIsInputHigh[3], true);
EXPECT_EQ(pinIsInputHigh[4], false);
EXPECT_EQ(pinIsInputHigh[5], false);
EXPECT_EQ(pinIsInputHigh[6], false);
EXPECT_EQ(pinIsInputHigh[7], false);
EXPECT_EQ(pinIsInputHigh[8], false);
EXPECT_EQ(pinIsInputHigh[9], false);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestLeftLessThanRight, TestInitRight) {
isLeftHand = false;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], false);
EXPECT_EQ(pinIsInputHigh[1], false);
EXPECT_EQ(pinIsInputHigh[2], false);
EXPECT_EQ(pinIsInputHigh[3], false);
EXPECT_EQ(pinIsInputHigh[4], true);
EXPECT_EQ(pinIsInputHigh[5], true);
EXPECT_EQ(pinIsInputHigh[6], true);
EXPECT_EQ(pinIsInputHigh[7], true);
EXPECT_EQ(pinIsInputHigh[8], true);
EXPECT_EQ(pinIsInputHigh[9], true);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestLeftLessThanRight, 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, 1); // one update received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
}
TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseRightSent) {
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);
uint8_t slave_state[32] = {0};
encoder_state_raw(slave_state);
EXPECT_EQ(slave_state[0], 0);
EXPECT_EQ(slave_state[1], 0xFF);
}
TEST_F(EncoderSplitTestLeftLessThanRight, TestMultipleEncodersRightReceived) {
isLeftHand = true;
encoder_init();
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, 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);
}

68
quantum/encoder/tests/encoder_tests_split.cpp → quantum/encoder/tests/encoder_tests_split_no_left.cpp
Unescape View File

@ -30,7 +30,7 @@ struct update {
bool clockwise; bool clockwise;
}; };
uint8_t uidx = 0; uint8_t updates_array_idx = 0;
update updates[32]; update updates[32];
bool isLeftHand; bool isLeftHand;
@ -41,8 +41,8 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC"); printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");
return true; return true;
} }
updates[uidx % 32] = {index, clockwise}; updates[updates_array_idx % 32] = {index, clockwise};
uidx++; updates_array_idx++;
return true; return true;
} }
@ -51,10 +51,10 @@ bool setAndRead(pin_t pin, bool val) {
return encoder_read(); return encoder_read();
} }
class EncoderTest : public ::testing::Test { class EncoderSplitTestNoLeft : public ::testing::Test {
protected: protected:
void SetUp() override { void SetUp() override {
uidx = 0; updates_array_idx = 0;
for (int i = 0; i < 32; i++) { for (int i = 0; i < 32; i++) {
pinIsInputHigh[i] = 0; pinIsInputHigh[i] = 0;
pins[i] = 0; pins[i] = 0;
@ -62,27 +62,27 @@ class EncoderTest : public ::testing::Test {
} }
}; };
TEST_F(EncoderTest, TestInitLeft) { TEST_F(EncoderSplitTestNoLeft, TestInitLeft) {
isLeftHand = true; isLeftHand = true;
encoder_init(); encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true); EXPECT_EQ(pinIsInputHigh[0], false);
EXPECT_EQ(pinIsInputHigh[1], true); EXPECT_EQ(pinIsInputHigh[1], false);
EXPECT_EQ(pinIsInputHigh[2], false); EXPECT_EQ(pinIsInputHigh[2], false);
EXPECT_EQ(pinIsInputHigh[3], false); EXPECT_EQ(pinIsInputHigh[3], false);
EXPECT_EQ(uidx, 0); EXPECT_EQ(updates_array_idx, 0); // no updates received
} }
TEST_F(EncoderTest, TestInitRight) { TEST_F(EncoderSplitTestNoLeft, TestInitRight) {
isLeftHand = false; isLeftHand = false;
encoder_init(); encoder_init();
EXPECT_EQ(pinIsInputHigh[0], false); EXPECT_EQ(pinIsInputHigh[0], true);
EXPECT_EQ(pinIsInputHigh[1], false); EXPECT_EQ(pinIsInputHigh[1], true);
EXPECT_EQ(pinIsInputHigh[2], true); EXPECT_EQ(pinIsInputHigh[2], true);
EXPECT_EQ(pinIsInputHigh[3], true); EXPECT_EQ(pinIsInputHigh[3], true);
EXPECT_EQ(uidx, 0); EXPECT_EQ(updates_array_idx, 0); // no updates received
} }
TEST_F(EncoderTest, TestOneClockwiseLeft) { TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseLeft) {
isLeftHand = true; isLeftHand = true;
encoder_init(); encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update. // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@ -91,12 +91,10 @@ TEST_F(EncoderTest, TestOneClockwiseLeft) {
setAndRead(0, true); setAndRead(0, true);
setAndRead(1, true); setAndRead(1, true);
EXPECT_EQ(uidx, 1); EXPECT_EQ(updates_array_idx, 0); // no updates received
EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, true);
} }
TEST_F(EncoderTest, TestOneClockwiseRightSent) { TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseRightSent) {
isLeftHand = false; isLeftHand = false;
encoder_init(); encoder_init();
// send 4 pulses. with resolution 4, that's one step and we should get 1 update. // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
@ -105,39 +103,23 @@ TEST_F(EncoderTest, TestOneClockwiseRightSent) {
setAndRead(2, true); setAndRead(2, true);
setAndRead(3, true); setAndRead(3, true);
uint8_t slave_state[2] = {0}; uint8_t slave_state[32] = {0};
encoder_state_raw(slave_state); encoder_state_raw(slave_state);
EXPECT_EQ((int8_t)slave_state[0], -1); EXPECT_EQ(slave_state[0], 0);
EXPECT_EQ(slave_state[1], 0xFF);
} }
/* this test will not work after the previous test. TEST_F(EncoderSplitTestNoLeft, TestMultipleEncodersRightReceived) {
* this is due to encoder_value[1] already being set to -1 when simulating the right half.
* When we now receive this update acting as the left half, there is no change.
* This is hard to mock, as the static values inside encoder.c normally exist twice, once on each half,
* but here, they only exist once.
*/
// TEST_F(EncoderTest, TestOneClockwiseRightReceived) {
// isLeftHand = true;
// encoder_init();
// uint8_t slave_state[2] = {255, 0};
// encoder_update_raw(slave_state);
// EXPECT_EQ(uidx, 1);
// EXPECT_EQ(updates[0].index, 1);
// EXPECT_EQ(updates[0].clockwise, true);
// }
TEST_F(EncoderTest, TestOneCounterClockwiseRightReceived) {
isLeftHand = true; isLeftHand = true;
encoder_init(); encoder_init();
uint8_t slave_state[2] = {0, 0}; 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); encoder_update_raw(slave_state);
EXPECT_EQ(uidx, 1); EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side
EXPECT_EQ(updates[0].index, 1); EXPECT_EQ(updates[0].index, 0);
EXPECT_EQ(updates[0].clockwise, false); EXPECT_EQ(updates[0].clockwise, false);
EXPECT_EQ(updates[1].index, 1);
EXPECT_EQ(updates[1].clockwise, true);
} }

118
quantum/encoder/tests/encoder_tests_split_no_right.cpp
Unescape View File

@ -0,0 +1,118 @@
/* Copyright 2021 Balz Guenat
*
* 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/>.
*/
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include <vector>
#include <algorithm>
#include <stdio.h>
extern "C" {
#include "encoder.h"
#include "encoder/tests/mock_split.h"
}
struct update {
int8_t index;
bool clockwise;
};
uint8_t updates_array_idx = 0;
update updates[32];
bool isLeftHand;
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!isLeftHand) {
// this method has no effect on slave half
printf("ignoring update on right hand (%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();
}
class EncoderSplitTestNoRight : public ::testing::Test {
protected:
void SetUp() override {
updates_array_idx = 0;
for (int i = 0; i < 32; i++) {
pinIsInputHigh[i] = 0;
pins[i] = 0;
}
}
};
TEST_F(EncoderSplitTestNoRight, TestInitLeft) {
isLeftHand = true;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], true);
EXPECT_EQ(pinIsInputHigh[1], true);
EXPECT_EQ(pinIsInputHigh[2], true);
EXPECT_EQ(pinIsInputHigh[3], true);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestNoRight, TestInitRight) {
isLeftHand = false;
encoder_init();
EXPECT_EQ(pinIsInputHigh[0], false);
EXPECT_EQ(pinIsInputHigh[1], false);
EXPECT_EQ(pinIsInputHigh[2], false);
EXPECT_EQ(pinIsInputHigh[3], false);
EXPECT_EQ(updates_array_idx, 0); // no updates received
}
TEST_F(EncoderSplitTestNoRight, 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, 1); // one updates received
EXPECT_EQ(updates[0].index, 0);
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);
}
TEST_F(EncoderSplitTestNoRight, TestMultipleEncodersRightReceived) {
isLeftHand = true;
encoder_init();
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 -- no right-hand encoders
}

6
quantum/encoder/tests/mock.h
Unescape View File

@ -19,12 +19,6 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0 }
#define ENCODERS_PAD_B \
{ 1 }
typedef uint8_t pin_t; typedef uint8_t pin_t;
extern bool pins[]; extern bool pins[];

16
quantum/encoder/tests/mock_split.h
Unescape View File

@ -20,20 +20,10 @@
#include <stdbool.h> #include <stdbool.h>
#define SPLIT_KEYBOARD #define SPLIT_KEYBOARD
/* Here, "pins" from 0 to 31 are allowed. */
#define ENCODERS_PAD_A \
{ 0 }
#define ENCODERS_PAD_B \
{ 1 }
#define ENCODERS_PAD_A_RIGHT \
{ 2 }
#define ENCODERS_PAD_B_RIGHT \
{ 3 }
typedef uint8_t pin_t; typedef uint8_t pin_t;
extern bool isLeftHand;
void encoder_state_raw(uint8_t* slave_state); void encoder_state_raw(uint8_t* slave_state);
void encoder_update_raw(uint8_t* slave_state); void encoder_update_raw(uint8_t* slave_state);
extern bool pins[]; extern bool pins[];
extern bool pinIsInputHigh[]; extern bool pinIsInputHigh[];

53
quantum/encoder/tests/rules.mk
Unescape View File

@ -1,13 +1,58 @@
encoder_DEFS := -DENCODER_MOCK_SINGLE encoder_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SINGLE
encoder_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock.h
encoder_SRC := \ encoder_SRC := \
platforms/test/timer.c \
$(QUANTUM_PATH)/encoder/tests/mock.c \ $(QUANTUM_PATH)/encoder/tests/mock.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests.cpp \ $(QUANTUM_PATH)/encoder/tests/encoder_tests.cpp \
$(QUANTUM_PATH)/encoder.c $(QUANTUM_PATH)/encoder.c
encoder_split_DEFS := -DENCODER_MOCK_SPLIT encoder_split_left_eq_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT
encoder_split_left_eq_right_INC := $(QUANTUM_PATH)/split_common
encoder_split_left_eq_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_left_eq_right.h
encoder_split_SRC := \ encoder_split_left_eq_right_SRC := \
platforms/test/timer.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \ $(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split.cpp \ $(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_eq_right.cpp \
$(QUANTUM_PATH)/encoder.c
encoder_split_left_gt_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT
encoder_split_left_gt_right_INC := $(QUANTUM_PATH)/split_common
encoder_split_left_gt_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_left_gt_right.h
encoder_split_left_gt_right_SRC := \
platforms/test/timer.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_gt_right.cpp \
$(QUANTUM_PATH)/encoder.c
encoder_split_left_lt_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT
encoder_split_left_lt_right_INC := $(QUANTUM_PATH)/split_common
encoder_split_left_lt_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_left_lt_right.h
encoder_split_left_lt_right_SRC := \
platforms/test/timer.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_lt_right.cpp \
$(QUANTUM_PATH)/encoder.c
encoder_split_no_left_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT
encoder_split_no_left_INC := $(QUANTUM_PATH)/split_common
encoder_split_no_left_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_no_left.h
encoder_split_no_left_SRC := \
platforms/test/timer.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_no_left.cpp \
$(QUANTUM_PATH)/encoder.c
encoder_split_no_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT
encoder_split_no_right_INC := $(QUANTUM_PATH)/split_common
encoder_split_no_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_no_right.h
encoder_split_no_right_SRC := \
platforms/test/timer.c \
$(QUANTUM_PATH)/encoder/tests/mock_split.c \
$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_no_right.cpp \
$(QUANTUM_PATH)/encoder.c $(QUANTUM_PATH)/encoder.c

6
quantum/encoder/tests/testlist.mk
Unescape View File

@ -1,3 +1,7 @@
TEST_LIST += \ TEST_LIST += \
encoder \ encoder \
encoder_split encoder_split_left_eq_right \
encoder_split_left_gt_right \
encoder_split_left_lt_right \
encoder_split_no_left \
encoder_split_no_right

4
quantum/split_common/transactions.c
Unescape View File

@ -180,7 +180,7 @@ static void master_matrix_handlers_slave(matrix_row_t master_matrix[], matrix_ro
static bool encoder_handlers_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) { static bool encoder_handlers_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
static uint32_t last_update = 0; static uint32_t last_update = 0;
uint8_t temp_state[NUMBER_OF_ENCODERS]; uint8_t temp_state[NUM_ENCODERS_MAX_PER_SIDE];
bool okay = read_if_checksum_mismatch(GET_ENCODERS_CHECKSUM, GET_ENCODERS_DATA, &last_update, temp_state, split_shmem->encoders.state, sizeof(temp_state)); 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); if (okay) encoder_update_raw(temp_state);
@ -188,7 +188,7 @@ static bool encoder_handlers_master(matrix_row_t master_matrix[], matrix_row_t s
} }
static void encoder_handlers_slave(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) { static void encoder_handlers_slave(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
uint8_t encoder_state[NUMBER_OF_ENCODERS]; uint8_t encoder_state[NUM_ENCODERS_MAX_PER_SIDE];
encoder_state_raw(encoder_state); encoder_state_raw(encoder_state);
// Always prepare the encoder state for read. // Always prepare the encoder state for read.
memcpy(split_shmem->encoders.state, encoder_state, sizeof(encoder_state)); memcpy(split_shmem->encoders.state, encoder_state, sizeof(encoder_state));

3
quantum/split_common/transport.h
Unescape View File

@ -42,7 +42,6 @@ bool transport_execute_transaction(int8_t id, const void *initiator2target_buf,
#ifdef ENCODER_ENABLE #ifdef ENCODER_ENABLE
# include "encoder.h" # include "encoder.h"
# define NUMBER_OF_ENCODERS (sizeof((pin_t[])ENCODERS_PAD_A) / sizeof(pin_t))
#endif // ENCODER_ENABLE #endif // ENCODER_ENABLE
#ifdef BACKLIGHT_ENABLE #ifdef BACKLIGHT_ENABLE
@ -67,7 +66,7 @@ typedef struct _split_master_matrix_sync_t {
#ifdef ENCODER_ENABLE #ifdef ENCODER_ENABLE
typedef struct _split_slave_encoder_sync_t { typedef struct _split_slave_encoder_sync_t {
uint8_t checksum; uint8_t checksum;
uint8_t state[NUMBER_OF_ENCODERS]; uint8_t state[NUM_ENCODERS_MAX_PER_SIDE];
} split_slave_encoder_sync_t; } split_slave_encoder_sync_t;
#endif // ENCODER_ENABLE #endif // ENCODER_ENABLE

8
quantum/util.h
Unescape View File

@ -24,3 +24,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// convert to string // convert to string
#define STR(s) XSTR(s) #define STR(s) XSTR(s)
#define XSTR(s) #s #define XSTR(s) #s
#if !defined(MIN)
# define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
#if !defined(MAX)
# define MAX(x, y) (((x) > (y)) ? (x) : (y))
#endif

Write Preview
Loading…
Cancel
Save