ErriezMCP23017.cpp

/*
 * MIT License
 *
 * Copyright (c) 2020 Erriez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <ErriezMCP23017.h>
#include <Wire.h>


ErriezMCP23017::ErriezMCP23017(uint8_t i2cAddress, TwoWire *twoWire) :
    _wire(twoWire), _i2cAddress(i2cAddress), _i2cStatus(0),
    _gpioPort(0), _gpioDir(0), _gpioPullup(0)
{
    // Nothing to do
}

//------------------------------------------------------------------------------
bool ErriezMCP23017::begin(bool reset)
{
    // Write default configuration to IOCON register
    registerWrite(MCP23017_REG_IOCON,
                  (REG_IOCON_VALUE << 8) | REG_IOCON_VALUE);

    // Return I2C write status
    if (_i2cStatus != 0) {
        // I2C register write failed
        return false;
    }

    if (reset) {
        // Disable interrupt pins
        setPortInterruptDisable(MCP23017_MASK_ALL_PINS);
        // Interrupt pin change
        registerWrite(MCP23017_REG_INTCON, 0);
        // Write port
        portWrite(_gpioPort);
        // Set port pull-up
        setPortPullup(_gpioPullup);
        // Set port direction
        setPortDirection(_gpioDir);
    }

    // Read current port state and release INTA pin
    _portStateLast = portRead();

    return true;
}

void ErriezMCP23017::pinMode(uint8_t pin, uint8_t mode)
{
    // Set pin mode
    if (pin < MCP23017_NUM_PINS) {
        switch (mode) {
            case OUTPUT:
                // Pin to output
                _gpioDir |= (1<<pin);
                break;
            case INPUT:
                // Disable pull-up
                _gpioPullup &= ~(1<<pin);
                // Pin to input
                _gpioDir &= ~(1<<pin);
                break;
            case INPUT_PULLUP:
                // Enable pull-up
                _gpioPullup |= (1<<pin);
                // Pin to input
                _gpioDir &= ~(1<<pin);
                break;
        }
        // Set port pull-up
        setPortPullup(_gpioPullup);
        // Set port direction
        setPortDirection(_gpioDir);
    }
}

void ErriezMCP23017::digitalWrite(uint8_t pin, uint8_t state)
{
    // Set pin level
    pinWrite(pin, (bool)state);
}

int ErriezMCP23017::digitalRead(uint8_t pin)
{
    // Read pin level
    return (int)pinRead(pin);
}

//------------------------------------------------------------------------------
void ErriezMCP23017::setPortDirection(uint16_t outputPins)
{
    // Store port direction
    _gpioDir = outputPins;
    // Set port direction
    registerWrite(MCP23017_REG_IODIR, ~(_gpioDir));
}

uint16_t ErriezMCP23017::getPortDirection()
{
    // Get port direction
    // Inverse value, because IODIR register: Bit '0': OUTPUT, '1': INPUT
    return ~(registerRead(MCP23017_REG_IODIR));
}

void ErriezMCP23017::setPortPullup(uint16_t pullupPins)
{
    // Store pull-up
    _gpioPullup = pullupPins;
    // Set pull-up pins
    registerWrite(MCP23017_REG_GPPU, _gpioPullup);
}

uint16_t ErriezMCP23017::getPortPullup()
{
    // Get pull-up pins
    return registerRead(MCP23017_REG_GPPU);
}

//------------------------------------------------------------------------------
void ErriezMCP23017::pinWrite(uint8_t pin, bool level)
{
    if (pin < MCP23017_NUM_PINS) {
        if (level == HIGH) {
            portWrite(_gpioPort | (1<<pin));
        } else {
            portWrite(_gpioPort & ~(1<<pin));
        }
    }
}

void ErriezMCP23017::pinToggle(uint8_t pin)
{
    if (pin < MCP23017_NUM_PINS) {
        // Toggle pin
        portToggle(1<<pin);
    }
}

bool ErriezMCP23017::pinRead(uint8_t pin)
{
    bool pinLevel = LOW;

    if (pin < MCP23017_NUM_PINS) {
        if (portRead() & (1<<pin)) {
            pinLevel = HIGH;
        }
    }
    return pinLevel;
}

void ErriezMCP23017::portWrite(uint16_t value)
{
    // Store pins
    _gpioPort = value;
    // Write GPIO pin levels
    registerWrite(MCP23017_REG_GPIO, _gpioPort);
}

void ErriezMCP23017::portToggle(uint16_t value)
{
    // Toggle and store pin levels
    _gpioPort ^= value;
    // Write GPIO pin levels
    registerWrite(MCP23017_REG_GPIO, _gpioPort);
}

void ErriezMCP23017::portMask(uint16_t maskSet, uint16_t maskClear)
{
    _gpioPort &= ~(maskClear);
    _gpioPort |= maskSet;
    registerWrite(MCP23017_REG_GPIO, _gpioPort);
}

uint16_t ErriezMCP23017::portRead()
{
    // NOTE: Bug in the MCP23017: Reading the GPIO register releases INT pin
    portState = registerRead(MCP23017_REG_GPIO);

    // Return port state
    return portState;
}

//------------------------------------------------------------------------------
void ErriezMCP23017::setInterruptPolarityINTA(bool activeHigh)
{
    uint16_t value;

    // Read configuration register
    value = registerRead(MCP23017_REG_IOCON);

    // Set polarity INT pin
    if (activeHigh) {
        // Active high
        value |= ((1<<IOCON_INTPOL) << 8) | (1<<IOCON_INTPOL);
    } else {
        // Active low [default]
        value &= ~((1<<IOCON_INTPOL) << 8) | (1<<IOCON_INTPOL);
    }

    // Write configuration register
    registerWrite(MCP23017_REG_IOCON, value);
}

uint16_t ErriezMCP23017::getPortInterruptMask()
{
    return registerRead(MCP23017_REG_GPINTEN);
}

void ErriezMCP23017::setPortInterruptEnable(uint16_t pins)
{
    uint16_t intenValue;

    // Input pins
    setPortDirection(_gpioDir & ~(pins));

    // Enable interrupt pins
    intenValue = registerRead(MCP23017_REG_GPINTEN);
    intenValue |= pins;
    registerWrite(MCP23017_REG_GPINTEN, intenValue);
}

void ErriezMCP23017::setPortInterruptDisable(uint16_t pins)
{
    uint16_t value;

    // Disable interrupt pins
    value = registerRead(MCP23017_REG_GPINTEN);
    value &= ~(pins);
    registerWrite(MCP23017_REG_GPINTEN, value);
}

bool ErriezMCP23017::interruptINTA()
{
    // Read interrupt flag register which holds only one pin change
    pinsChanged = registerRead(MCP23017_REG_INTF);

    // A read of GPIO registers clears INTF register releases MCP23017 INTA pin
    portState = portRead();

    // Calculate changed pins
    pinsChanged |= _portStateLast ^ portState;

    // Calculate pins falling
    pinsFalling = ~(portState) & pinsChanged;
    // Calculate pins rising
    pinsRising = portState & pinsChanged;

    // Check if pin changed, but missed previous edge
    if ((_portStateLast & pinsChanged) == (pinsChanged & portState)) {
        pinsFalling |= pinsChanged;
        pinsRising |= pinsChanged;
    }

    // Store current pin state
    _portStateLast = portState;

    if (pinsChanged) {
        return true;
    } else {
        return false;
    }
}

//------------------------------------------------------------------------------
uint16_t ErriezMCP23017::registerRead(uint8_t reg)
{
    _wire->beginTransmission(_i2cAddress);
    _wire->write(reg & MCP23017_MASK_REG_A);
    _i2cStatus = _wire->endTransmission(false);

    // Read two 8-bit register values with auto address increment
    (void)_wire->requestFrom(_i2cAddress, (uint8_t)2);

    // Return I2C read buffer
    return _wire->read() | (_wire->read() << 8);
}

void ErriezMCP23017::registerWrite(uint8_t reg, uint16_t value)
{
    // Write 16-bit value to two MCP23017 registers
    _wire->beginTransmission(_i2cAddress);
    _wire->write(reg & MCP23017_MASK_REG_A);
    _wire->write(value & 0xff);
    _wire->write(value >> 8);
    // Generate I2C stop and store transfer status
    _i2cStatus = _wire->endTransmission(true);
}

uint8_t ErriezMCP23017::getI2CStatus()
{
    /* Status of the endTransmission (I2C addressing, repeated start ignored):
     */
    return _i2cStatus;
}

void ErriezMCP23017::dumpRegisters(HardwareSerial *serial)
{
    serial->println(F("MCP23017 registers:"));

    serial->print(F("  00 IODIR:   0x"));
    serial->println(registerRead(MCP23017_REG_IODIR), HEX);
    serial->print(F("  02 IPOL:    0x"));
    serial->println(registerRead(MCP23017_REG_IPOL), HEX);
    serial->print(F("  04 GPINTEN: 0x"));
    serial->println(registerRead(MCP23017_REG_GPINTEN), HEX);
    serial->print(F("  06 DEFVAL:  0x"));
    serial->println(registerRead(MCP23017_REG_DEFVAL), HEX);
    serial->print(F("  08 INTCON:  0x"));
    serial->println(registerRead(MCP23017_REG_INTCON), HEX);
    serial->print(F("  0A IOCON:   0x"));
    serial->println(registerRead(MCP23017_REG_IOCON), HEX);
    serial->print(F("  0C GPPU:    0x"));
    serial->println(registerRead(MCP23017_REG_GPPU), HEX);
    serial->print(F("  0E INTF:    0x"));
    serial->println(registerRead(MCP23017_REG_INTF), HEX);
    serial->print(F("  10 INTCAP:  0x"));
    serial->println(registerRead(MCP23017_REG_INTCAP), HEX);
    serial->print(F("  12 GPIO:    0x"));
    serial->println(registerRead(MCP23017_REG_GPIO), HEX);
    serial->print(F("  14 OLAT:    0x"));
    serial->println(registerRead(MCP23017_REG_OLAT), HEX);
}