Browse Source
RFC: add a simple implementation of the ploopy optical encoder (#17912)
pull/18041/head
alaviss
1 year ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 165 additions and 43 deletions
Split View
Diff Options
-
+1 -1keyboards/ploopyco/mouse/mouse.c
-
+10 -1keyboards/ploopyco/opt_encoder.c
-
+4 -38keyboards/ploopyco/opt_encoder.h
-
+147 -0keyboards/ploopyco/opt_encoder_simple.c
-
+1 -1keyboards/ploopyco/trackball/trackball.c
-
+2 -2keyboards/ploopyco/trackball_mini/trackball_mini.c
+ 1
- 1
keyboards/ploopyco/mouse/mouse.c
View File
+ 10
- 1
keyboards/ploopyco/opt_encoder.c
View File
+ 4
- 38
keyboards/ploopyco/opt_encoder.h
View File
+ 147
- 0
keyboards/ploopyco/opt_encoder_simple.c
View File
| @ -0,0 +1,147 @@ | |||
| /* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com> | |||
| * Copyright 2020 Ploopy Corporation | |||
| * Copyright 2022 Leorize <leorize+oss@disroot.org> | |||
| * | |||
| * 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 "opt_encoder.h" | |||
| #include "util.h" | |||
| #include <stdbool.h> | |||
| #include <stdint.h> | |||
| /* An alternative implementation for interpreting the encoder status: | |||
| * | |||
| * From graphing the phototransistor voltages, the peak and baseline appears to | |||
| * be rather stable. Therefore there is no need to average them out, and instead | |||
| * just simply store the min and max voltages of each phototransistor. | |||
| * | |||
| * This algorithm then distinguish between high and low states by employing an | |||
| * approach similar to a Schmitt trigger: a low and high threshold is defined | |||
| * for each phototransistor based on their min and max voltages. | |||
| * | |||
| * Currently, the thresholds are: | |||
| * | |||
| * * High threshold: The upper quarter of the voltage range. | |||
| * * Low threshold: The lower quarter of the voltage range. | |||
| * | |||
| * these thresholds are defined for each phototransistor. | |||
| * | |||
| * For a state to cross from high -> low, it must fall below the low threshold. | |||
| * Similarly, to cross from low -> high, the voltage must be higher than the | |||
| * high threshold. | |||
| * | |||
| * Having two distinct thresholds filters out the bulk of noise from the | |||
| * phototransistors. | |||
| * | |||
| * For converting the resulting high and low signals into rotation, a simple | |||
| * quadrature decoder is used. | |||
| */ | |||
| /* The minimum value returned by the ADC */ | |||
| #define ENCODER_MIN 0 | |||
| /* The maximum value returned by the ADC */ | |||
| #define ENCODER_MAX 1023 | |||
| /* Utilities for composing the encoder state */ | |||
| #define MAKE_STATE(HI_A, HI_B) (((uint8_t)((HI_A) & 0x1) << 1) | ((uint8_t)((HI_B) & 0x1))) | |||
| #define STATE_A(st) ((st & 0x2) >> 1) | |||
| #define STATE_B(st) (st & 0x1) | |||
| #define LOLO MAKE_STATE(0, 0) | |||
| #define HILO MAKE_STATE(1, 0) | |||
| #define LOHI MAKE_STATE(0, 1) | |||
| typedef enum { | |||
| CALIBRATION, /* Recalibrate encoder state by waiting for a 01 -> 00 or 10 -> 00 transistion */ | |||
| DECODE /* Translate changes in the encoder state into movement */ | |||
| } encoder_state_t; | |||
| static encoder_state_t mode; | |||
| static uint8_t lastState; | |||
| static uint16_t lowA; | |||
| static uint16_t highA; | |||
| static uint16_t lowB; | |||
| static uint16_t highB; | |||
| #define MOVE_UP 1 | |||
| #define MOVE_DOWN -1 | |||
| #define MOVE_NONE 0 | |||
| #define MOVE_ERR 0x7F | |||
| static const uint8_t movement[] = { | |||
| // 00 -> 00, 01, 10, 11 | |||
| MOVE_NONE, MOVE_DOWN, MOVE_UP, MOVE_ERR, | |||
| // 01 -> 00, 01, 10, 11 | |||
| MOVE_UP, MOVE_NONE, MOVE_ERR, MOVE_DOWN, | |||
| // 10 -> 00, 01, 10, 11 | |||
| MOVE_DOWN, MOVE_ERR, MOVE_NONE, MOVE_UP, | |||
| // 11 -> 00, 01, 10, 11 | |||
| MOVE_ERR, MOVE_UP, MOVE_DOWN, MOVE_NONE | |||
| }; | |||
| void opt_encoder_init(void) { | |||
| mode = CALIBRATION; | |||
| lastState = 0; | |||
| lowA = ENCODER_MAX; | |||
| lowB = ENCODER_MAX; | |||
| highA = ENCODER_MIN; | |||
| highB = ENCODER_MIN; | |||
| } | |||
| int8_t opt_encoder_handler(uint16_t encA, uint16_t encB) { | |||
| int8_t result = 0; | |||
| highA = MAX(encA, highA); | |||
| lowA = MIN(encA, lowA); | |||
| highB = MAX(encB, highB); | |||
| lowB = MIN(encB, lowB); | |||
| /* Only compute the thresholds after a large enough range is established */ | |||
| if (highA - lowA > SCROLL_THRESH_RANGE_LIM && highB - lowB > SCROLL_THRESH_RANGE_LIM) { | |||
| const int16_t lowThresholdA = (highA + lowA) / 4; | |||
| const int16_t highThresholdA = (highA + lowA) - lowThresholdA; | |||
| const int16_t lowThresholdB = (highB + lowB) / 4; | |||
| const int16_t highThresholdB = (highB + lowB) - lowThresholdB; | |||
| uint8_t state = MAKE_STATE( | |||
| STATE_A(lastState) ? encA > lowThresholdA : encA > highThresholdA, | |||
| STATE_B(lastState) ? encB > lowThresholdB : encB > highThresholdB | |||
| ); | |||
| switch (mode) { | |||
| case CALIBRATION: | |||
| if ((lastState == HILO && state == LOLO) | |||
| || (lastState == LOHI && state == LOLO)) | |||
| mode = DECODE; | |||
| else | |||
| mode = CALIBRATION; | |||
| break; | |||
| case DECODE: | |||
| result = movement[lastState * 4 + state]; | |||
| /* If we detect a state change that should not be possible, | |||
| * then the wheel might have moved too fast and we need to | |||
| * recalibrate the encoder position. */ | |||
| mode = result == MOVE_ERR ? CALIBRATION : mode; | |||
| result = result == MOVE_ERR ? MOVE_NONE : result; | |||
| break; | |||
| } | |||
| lastState = state; | |||
| } | |||
| return result; | |||
| } | |||