encoder_quadrature.h

#pragma once
 
#include <cstdint>
 
namespace deluge::hid::encoders {

class QuadratureDecoder {
public:
    void initialize(bool a, bool b) { committed_ = sampled_ = encode(a, b); }

    int8_t observe(bool a, bool b, bool invert = false) {
        const uint8_t next = encode(a, b);
        if ((sampled_ ^ next) == 0b11) {
            return 0;
        }
        const int8_t movement = step(next);
        return invert ? -movement : movement;
    }

    int8_t observeAEdge(bool a, bool b, bool invert = false) {
        const uint8_t next = encode(a, b);
        int8_t movement = 0;
        if ((sampled_ ^ next) == 0b11) {
            movement += step(sampled_ ^ 0b01);
        }
        movement += step(next);
        return invert ? -movement : movement;
    }
 
private:
    int8_t step(uint8_t next) {
        if ((committed_ ^ next) != 0b11) {
            // Either back where we were last confirmed (a bounce), or only one pin away from it
            // (unconfirmed). Neither reports movement.
            sampled_ = next;
            return 0;
        }
        // Both pins now differ from the confirmed state, so the edge to `sampled_` was real.
        const int8_t movement = transition(committed_, sampled_);
        committed_ = sampled_;
        sampled_ = next;
        return movement;
    }

    static constexpr uint8_t encode(bool a, bool b) { return (static_cast<uint8_t>(a) << 1) | b; }

    static constexpr int8_t transition(uint8_t from, uint8_t to) {
        constexpr int8_t table[16] = {0, 1, -1, 0, -1, 0, 0, 1, 1, 0, 0, -1, 0, -1, 1, 0};
        return table[(from << 2) | to];
    }

    uint8_t committed_ = 0;

    uint8_t sampled_ = 0;
};
 
} // namespace deluge::hid::encoders