diff options
Diffstat (limited to 'keyboards/ploopyco/opt_encoder_simple.c')
| -rw-r--r-- | keyboards/ploopyco/opt_encoder_simple.c | 147 | 
1 files changed, 147 insertions, 0 deletions
| diff --git a/keyboards/ploopyco/opt_encoder_simple.c b/keyboards/ploopyco/opt_encoder_simple.c new file mode 100644 index 0000000000..c30deb9ca4 --- /dev/null +++ b/keyboards/ploopyco/opt_encoder_simple.c @@ -0,0 +1,147 @@ +/* Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <[email protected]> + * Copyright 2020 Ploopy Corporation + * Copyright 2022 Leorize <[email protected]> + * + * 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; +} | 
