RegisterEncoders.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Settings/NamespaceSettings.hpp>
#include <AH/Settings/Warnings.hpp>
 
AH_DIAGNOSTIC_WERROR() // Enable errors on warnings
 
AH_DIAGNOSTIC_EXTERNAL_HEADER()
#include <AH/Arduino-Wrapper.h>
AH_DIAGNOSTIC_POP()
 
#include <AH/Containers/Array.hpp>
#include <AH/STL/limits>
#include <AH/STL/type_traits>
 
BEGIN_AH_NAMESPACE
 
constexpr static int8_t RegisterEncodersLUT[16] = {
    0,  // 0 0 0 0
    +1, // 0 0 0 1
    -1, // 0 0 1 0
    +2, // 0 0 1 1
    -1, // 0 1 0 0
    0,  // 0 1 0 1
    -2, // 0 1 1 0
    +1, // 0 1 1 1
    +1, // 1 0 0 0
    -2, // 1 0 0 1
    0,  // 1 0 1 0
    -1, // 1 0 1 1
    +2, // 1 1 0 0
    -1, // 1 1 0 1
    +1, // 1 1 1 0
    0,  // 1 1 1 1
};
 
template <class RegisterType, uint8_t NumEnc,
          class EncoderPositionType = int32_t, bool InterruptSafe = false>
class RegisterEncoders {
  private:
    static_assert(std::is_unsigned<RegisterType>::value,
                  "RegisterType should be an unsigned integer type");
 
    using EncoderPositionStorageType =
        typename std::conditional<InterruptSafe, volatile EncoderPositionType,
                                  EncoderPositionType>::type;
 
    using StateStorageType =
        typename std::conditional<InterruptSafe, volatile RegisterType,
                                  RegisterType>::type;
 
    StateStorageType state = std::numeric_limits<RegisterType>::max();
    Array<EncoderPositionStorageType, NumEnc> positions {{}};
 
  public:
    void reset() {
        positions = {{}};
        state = std::numeric_limits<RegisterType>::max();
    }
 
    void reset(RegisterType resetstate) {
        positions = {{}};
        state = resetstate;
    }
 
    bool update(RegisterType newstate) {
        RegisterType oldstate = state;
 
        // If the state didn't change, do nothing
        if (newstate == oldstate)
            return false;
 
        // Save the new state
        state = newstate;
 
        // For each encoder, compare the new state of its two pins
        // to the old state. Combine the four states into a 4-bit
        // number and use a lookup table to determine the delta between
        // the two encoder positions.
        for (uint8_t i = 0; i < NumEnc; ++i) {
            // Top two bits are new pin states
            uint8_t change = static_cast<uint8_t>(newstate) & 0b11;
            change <<= 2;
            // Bottom two bits are old pin states
            change |= static_cast<uint8_t>(oldstate) & 0b11;
            auto delta =
                static_cast<EncoderPositionType>(RegisterEncodersLUT[change]);
            if (delta != 0) // small speedup on AVR
                positions[i] += delta;
            oldstate >>= 2;
            newstate >>= 2;
        }
        return true;
    }
 
    EncoderPositionType read(uint8_t idx) const {
        if (InterruptSafe) {
            noInterrupts();
            EncoderPositionType ret = positions[idx];
            interrupts();
            return ret;
        } else {
            return positions[idx];
        }
    }
 
    EncoderPositionType readAndReset(uint8_t idx) {
        if (InterruptSafe) {
            noInterrupts();
            EncoderPositionType ret = positions[idx];
            positions[idx] = 0;
            interrupts();
            return ret;
        } else {
            EncoderPositionType ret = positions[idx];
            positions[idx] = 0;
            return ret;
        }
    }
 
    void write(uint8_t idx, EncoderPositionType pos) {
        if (InterruptSafe) {
            noInterrupts();
            positions[idx] = pos;
            interrupts();
        } else {
            positions[idx] = pos;
        }
    }
 
    class Encoder {
      private:
        friend class RegisterEncoders;
 
        EncoderPositionStorageType *position;
 
        Encoder(EncoderPositionStorageType *position) : position(position) {}
 
      public:
        EncoderPositionType read() const {
            if (InterruptSafe) {
                noInterrupts();
                EncoderPositionType ret = *position;
                interrupts();
                return ret;
            } else {
                return *position;
            }
        }
 
        EncoderPositionType readAndReset() {
            if (InterruptSafe) {
                noInterrupts();
                EncoderPositionType ret = *position;
                *position = 0;
                interrupts();
                return ret;
            } else {
                EncoderPositionType ret = *position;
                *position = 0;
                return ret;
            }
        }
 
        void write(EncoderPositionType pos) {
            if (InterruptSafe) {
                noInterrupts();
                *position = pos;
                interrupts();
            } else {
                *position = pos;
            }
        }
 
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5
        // begin_if_possible doesn't work on GCC 4.x and earlier, so provide a
        // dummy begin method instead.
        void begin() {}
#endif
    };
 
    Encoder operator[](uint8_t index) {
        if (index >= NumEnc)
            index = NumEnc - 1;
        return &positions[index];
    }
};
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()