MCP23017Encoders.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Arduino-Wrapper.h>
 
#include <AH/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
#include <AH/Hardware/RegisterEncoders.hpp>
#include <AH/Settings/NamespaceSettings.hpp>
 
BEGIN_AH_NAMESPACE

template <class WireType, class EncoderPositionType = int32_t,
          bool InterruptSafe = false>
class MCP23017Encoders {
  private:
    constexpr static uint8_t I2C_BASE_ADDRESS = 0x20;
 
    WireType *wire;
    uint8_t address;
    pin_t interrupt_pin;
 
    using RegisterEncoderType =
        RegisterEncoders<uint16_t, 8, EncoderPositionType, InterruptSafe>;
 
    RegisterEncoderType encs;
 
  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, size_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

        encs.reset(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();
        encs.update(newstate);
    }

    EncoderPositionType read(uint8_t idx) const { return encs.read(idx); }

    EncoderPositionType readAndReset(uint8_t idx) {
        return encs.readAndReset(idx);
    }

    void write(uint8_t idx, EncoderPositionType pos) { encs.write(idx, pos); }

    using MCP23017Encoder = typename RegisterEncoderType::Encoder;

    MCP23017Encoder operator[](uint8_t index) { return encs[index]; }
};
 
END_AH_NAMESPACE