MCP23017Encoders.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/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
#include <AH/STL/type_traits> // std::conditional
 
BEGIN_AH_NAMESPACE
 
constexpr static int8_t MCP23017Encoders_lut[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 WireType, class EncoderPositionType = int32_t,
          bool InterruptSafe = false>
class MCP23017Encoders {
  private:
    using EncoderPositionStorageType =
        typename std::conditional<InterruptSafe, volatile EncoderPositionType,
                                  EncoderPositionType>::type;
    using StateStorageType =
        typename std::conditional<InterruptSafe, volatile uint16_t,
                                  uint16_t>::type;
 
    constexpr static uint8_t I2C_BASE_ADDRESS = 0x20;
 
    WireType *wire;
    uint8_t address;
    pin_t interrupt_pin;
 
    StateStorageType state;
    EncoderPositionStorageType positions[8];
 
  protected:
    template <size_t N>
    void writeI2C(const uint8_t (&values)[N]) {
        this->wire->beginTransmission(address);
        this->wire->write(values, N);
        this->wire->endTransmission();
    }
 
    template <class... Args>
    void writeI2C(uint8_t addr, Args... values) {
        const uint8_t v[] = {addr, static_cast<uint8_t>(values)...};
        writeI2C(v);
    }
 
    uint16_t readGPIO() {
        // No need to specify the register address, since this was done in the
        // begin method, and the MCP23017 mode was set to Byte mode with
        // IOCON.BANK = 0 (see §3.2.1 in the datasheet).
        //
        // TODO:
        // For some reason, it sometimes seems to mess up though, and it'll read
        // the wrong register, so we'll select the register again (for now).
 
        writeI2C(0x12); // GPIOA
 
        this->wire->requestFrom(address, uint8_t(2));
        uint8_t a = this->wire->read();
        uint16_t b = this->wire->read();
        return a | (b << 8);
    }
 
  public:
    MCP23017Encoders(WireType &wire, uint8_t addr_offset = 0,
                     pin_t interrupt_pin = NO_PIN)
        : wire(&wire), address(I2C_BASE_ADDRESS | addr_offset),
          interrupt_pin(interrupt_pin) {}
 
    void begin() {
        // Set the IOCON register (configuration register)
        writeI2C(0x0A, // IOCON register for BANK=0
                 0b01100100);
        //         │││││││└─ Unimplemented
        //         ││││││└── INTPOL = Active-low
        //         │││││└─── ODR    = Open-drain output (overrides the INTPOL bit)
        //         ││││└──── HAEN   = Disables the MCP23S17 address pins
        //         │││└───── DISSLW = Slew rate enabled
        //         ││└────── SEQOP  = Sequential operation disabled, address pointer does not increment
        //         │└─────── MIRROR = The INT pins are internally connected
        //         └──────── BANK   = The registers are in the same bank (addresses are sequential)
 
        // Set all GPIO pins to input mode
        writeI2C(0x00,  // IODIRA
                 0xFF,  // input mode for GPIO A
                 0xFF); // input mode for GPIO B
 
        // Enable all pin change interrupts
        writeI2C(0x04,  // GPINTENA
                 0xFF,  // interrupt enable for GPIO A
                 0xFF); // interrupt enable for GPIO B
 
        // Enable all internal pullups
        writeI2C(0x0C,  // GPPUA
                 0xFF,  // pullup enable for GPIO A
                 0xFF); // pullup enable for GPIO B
 
        // Interrupts are configured in open-drain mode, so enable
        // the internal pullup resistor on the Arduino pin that
        // reads the interrupt pin.
        if (interrupt_pin != NO_PIN)
            ExtIO::pinMode(interrupt_pin, INPUT_PULLUP);
 
        // Set the address pointer to the GPIOA register.
        // This means that subsequent reads will all toggle between the
        // GPIOA and GPIOB register, so we can speedup reading the GPIO
        // by not having to send an opcode/register address each time.
        writeI2C(0x12); // GPIOA
 
        state = readGPIO();
    }
 
    void update() {
        // Only update if a pin change interrupt happened
        if (interrupt_pin != NO_PIN &&
            ExtIO::digitalRead(interrupt_pin) == HIGH)
            return;
        // Read both GPIO A and B
        uint16_t newstate = readGPIO();
        uint16_t oldstate = state;
 
        // If the state didn't change, do nothing
        if (newstate == oldstate)
            return;
 
        // 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 < 8; ++i) {
            uint8_t change =
                uint8_t(newstate) & 0b11; // Top two bits are new pin states
            change <<= 2;
            change |=
                uint8_t(oldstate) & 0b11; // Bottom two bits are old pin states
            auto delta =
                static_cast<EncoderPositionType>(MCP23017Encoders_lut[change]);
            if (delta != 0) { // small speedup on AVR
                positions[i] += delta;
            }
            oldstate >>= 2;
            newstate >>= 2;
        }
    }
 
    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 MCP23017Encoder {
      private:
        friend class MCP23017Encoders;
 
        EncoderPositionStorageType *position;
 
        MCP23017Encoder(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;
            }
        }
    };
 
    MCP23017Encoder operator[](uint8_t index) {
        if (index >= 8)
            index = 7;
        return &positions[index];
    }
};
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()