encoder.hpp

Go to the documentation of this file.

/**
 * @file encoder.hpp
 * @brief Quadrature encoder component — Gray code state machine
 * @ingroup components
 *
 * Encoder tracks rotational position from A/B quadrature signals.
 * Uses a 16-entry transition table for robust decoding.
 * The encoder's push-button is a separate Button component (composable).
 *
 * Usage:
 *   sbl::components::control::Encoder enc;
 *   enc.update(gpio_a, gpio_b);       // Feed A/B each tick
 *   int32_t d = enc.delta();           // Steps since last check (+CW/-CCW)
 *   int32_t pos = enc.position();      // Cumulative position
 */
 
#ifndef SBL_COMPONENTS_CONTROL_ENCODER_HPP_
#define SBL_COMPONENTS_CONTROL_ENCODER_HPP_
 
#include <cstdint>
 
namespace sbl {
namespace components {
namespace control {
 
/**
 * @brief Quadrature encoder with Gray code state machine and position tracking
 *
 * @note All public methods are ISR-safe — pure state machine with no hardware I/O.
 */
class Encoder {
public:
    Encoder() : state_(0), delta_(0), position_(0) {}
 
    /**
     * @brief Feed quadrature signals
     *
     * Call once per update cycle with current A and B readings.
     * The state machine detects CW/CCW transitions and accumulates delta.
     *
     * @param a Channel A reading
     * @param b Channel B reading
     */
    void update(bool a, bool b) {
        // Encode new state as 2-bit: [B:A]
        uint8_t new_state = (b ? 2u : 0u) | (a ? 1u : 0u);
 
        // Build 4-bit lookup index: [old_B:old_A:new_B:new_A]
        uint8_t idx = (state_ << 2) | new_state;
 
        // Transition table: +1 = CW, -1 = CCW, 0 = no change or invalid
        // Index is [old_state(2 bits) : new_state(2 bits)]
        static constexpr int8_t table[16] = {
            //  00→00, 00→01, 00→10, 00→11
                 0,    +1,    -1,     0,
            //  01→00, 01→01, 01→10, 01→11
                -1,     0,     0,    +1,
            //  10→00, 10→01, 10→10, 10→11
                +1,     0,     0,    -1,
            //  11→00, 11→01, 11→10, 11→11
                 0,    -1,    +1,     0,
        };
 
        int8_t step = table[idx];
        delta_ += step;
        position_ += step;
 
        state_ = new_state;
    }
 
    /**
     * @brief Steps since last delta() call
     *
     * Positive = CW, negative = CCW. Resets on read.
     */
    int32_t delta() {
        int32_t d = delta_;
        delta_ = 0;
        return d;
    }
 
    /** @brief Cumulative position (does not reset) */
    int32_t position() const { return position_; }
 
    /** @brief Reset all state */
    void reset() {
        state_ = 0;
        delta_ = 0;
        position_ = 0;
    }
 
private:
    uint8_t state_;   ///< Previous [B:A] state
    int32_t delta_;   ///< Accumulated since last delta() call
    int32_t position_;  ///< Cumulative position
};
 
} // namespace control
} // namespace components
} // namespace sbl
 
#endif // SBL_COMPONENTS_CONTROL_ENCODER_HPP_