.. _program_listing_file_src_mcp23008.cpp:

Program Listing for File mcp23008.cpp
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_mcp23008.cpp>` (``src/mcp23008.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include <cstdint>
   
   #include "mcp23008/mcp23008.hh"
   
   using iplo::MCP23008;
   using iplo::MCP230XXStatus;
   
   MCP23008::MCP23008(I2C& bus, std::uint8_t address) : MCP230XX(bus, address) {}
   
   bool MCP23008::begin() {
       _bus.selectDevice(_address);
   
       if (!isConnected()) {
           return false;
       }
       if (!writeRegister(MCP23008Registers::IOCR, 0b00100000)) {
           return false;
       }
       if (!writeRegister(MCP23008Registers::PUR_A, 0xFF)) {
           return false;
       }
   
       return true;
   }
   
   bool MCP23008::isConnected() {
       auto res = _bus.readByte();
       if (res < 0) {
           _error = I2C_ERROR;
           return false;
       }
   
       _error = OK;
       return true;
   }
   
   bool MCP23008::pinMode(std::uint8_t pin, PinMode mode) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return false;
       }
   
       if ((mode != PinMode::INPUT) && (mode != PinMode::INPUT_PULLUP) && (mode != PinMode::OUTPUT)) {
           _error = VALUE_ERROR;
           return false;
       }
   
       auto registerValue = readRegister(MCP23008Registers::DDR_A);
       if (_error != OK) {
           return false;
       }
   
       if (mode == PinMode::INPUT || mode == PinMode::INPUT_PULLUP) {
           registerValue |= 1 << pin;
       } else {
           registerValue &= ~(1 << pin);
       }
   
       writeRegister(MCP23008Registers::DDR_A, registerValue);
       if (_error != OK) {
           return false;
       }
   
       return true;
   }
   
   bool MCP23008::digitalWrite(std::uint8_t pin, std::uint8_t value) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return false;
       }
   
       auto registerValue = readRegister(MCP23008Registers::GPIO_A);
       if (_error != OK) {
           return false;
       }
   
       value ? registerValue |= 1 << pin : registerValue &= ~(1 << pin);
   
       writeRegister(MCP23008Registers::GPIO_A, registerValue);
       if (_error != OK) {
           return false;
       }
   
       return true;
   }
   
   std::uint8_t MCP23008::digitalRead(std::uint8_t pin) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return INVALID_READ;
       }
   
       const auto registerValue = readRegister(MCP23008Registers::GPIO_A);
       if (_error != OK) {
           return INVALID_READ;
       }
   
       return registerValue & 1 << pin ? 1 : 0;
   }
   
   bool MCP23008::setPolarity(std::uint8_t pin, bool reversed) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return false;
       }
   
       auto registerValue = readRegister(MCP23008Registers::POL_A);
       if (_error != OK) {
           return false;
       }
   
       reversed ? registerValue |= 1 << pin : registerValue &= ~(1 << pin);
   
       writeRegister(MCP23008Registers::POL_A, registerValue);
       if (_error != OK) {
           return false;
       }
   
       return true;
   }
   
   bool MCP23008::getPolarity(std::uint8_t pin, bool& reversed) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return false;
       }
   
       const auto registerValue = readRegister(MCP23008Registers::POL_A);
       if (_error != OK) {
           return false;
       }
   
       reversed = (registerValue & 1 << pin) > 0;
       return true;
   }
   
   bool MCP23008::setPullUp(std::uint8_t pin, bool pullUp) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return false;
       }
   
       auto registerValue = readRegister(MCP23008Registers::PUR_A);
       if (_error != OK) {
           return false;
       }
   
       pullUp ? registerValue |= 1 << pin : registerValue &= ~(1 << pin);
   
       writeRegister(MCP23008Registers::PUR_A, registerValue);
       if (_error != OK) {
           return false;
       }
   
       return true;
   }
   
   bool MCP23008::getPullUp(std::uint8_t pin, bool& pullUp) {
       if (pin > 7) {
           _error = PIN_ERROR;
           return false;
       }
   
       const auto registerValue = readRegister(MCP23008Registers::PUR_A);
       if (_error != OK) {
           return false;
       }
   
       pullUp = (registerValue & 1 << pin) > 0;
       return true;
   }
   
   bool MCP23008::pinMode8(std::uint8_t value) {
       return writeRegister(MCP23008Registers::DDR_A, value);
   }
   
   bool MCP23008::digitalWrite8(std::uint8_t value) {
       return writeRegister(MCP23008Registers::GPIO_A, value);
   }
   
   std::uint8_t MCP23008::digitalRead8() {
       return readRegister(MCP23008Registers::GPIO_A);
   }
   
   bool MCP23008::setPolarity8(std::uint8_t mask) {
       return writeRegister(MCP23008Registers::POL_A, mask);
   }
   
   bool MCP23008::getPolarity8(std::uint8_t& mask) {
       mask = readRegister(MCP23008Registers::POL_A);
       return _error == OK;
   }
   
   bool MCP23008::setPullUp8(std::uint8_t mask) {
       return writeRegister(MCP23008Registers::PUR_A, mask);
   }
   
   bool MCP23008::getPullUp8(uint8_t& mask) {
       mask = readRegister(MCP23008Registers::PUR_A);
       return _error == OK;
   }
   
   std::uint16_t MCP23008::readAll() {
       return digitalRead8();
   }
   
   std::uint8_t MCP23008::extractPinValue(std::uint8_t registerValue, std::uint8_t pin) {
       return registerValue & 1 << pin ? 1 : 0;
   }