PinGroup.h

Go to the documentation of this file.

#include "Pin.h"

#pragma once

class PinGroup {
  public:
    template<size_t N>
    PinGroup(Pin (&pins)[N]) {
      _offset = pins[0].getOffset();
      _PIN = pins[0].getPIN();
      _PORT = pins[0].getPORT();
      _DDR = pins[0].getDDR();
      _numbers[0] = pins[0].getNumber();
      _valid = true;

      for (int i = 1; i < N; i++) {
        if (_DDR != pins[i].getDDR()) {
          _valid = false;
        }
        _offset |= pins[i].getOffset();
        _numbers[i] = pins[i].getNumber();
      }
      _ioffset = ~_offset;
    }

    bool operator ==(uint8_t value) {
      uint8_t status = *_PIN;
      if ((status & _offset) == _offset) {
        return (value == HIGH);
      } else if ((status | _ioffset) == _ioffset) {
        return (value == LOW);
      } else {
        return false;
      }
    }

    bool operator !=(uint8_t value) {
      uint8_t status = *_PIN;
      if ((status & _offset) == _offset) {
        return (value == LOW);
      } else if ((status | _ioffset) == _ioffset) {
        return (value == HIGH);
      } else {
        return false;
      }
    }

    PinGroup& operator =(uint8_t state) {
      uint8_t oldSREG = SREG;
      cli();
      if (state == LOW) {
        PORT_LOW;
      } else {
        PORT_HIGH;
      }
      SREG = oldSREG;

      return *this;
    }

    uint8_t* getNumbers() {
      return _numbers;
    }

    uint8_t getOffset() {
      return _offset;
    }

    uint8_t getInverseOffset() {
      return _ioffset;
    }

    volatile uint8_t* getPIN() {
      return _PIN;
    }

    volatile uint8_t* getPORT() {
      return _PORT;
    }

    volatile uint8_t* getDDR() {
      return _DDR;
    }

    uint8_t getMode() {
      uint8_t status = *_DDR;
      if ((status & _offset) == _offset) {
        return OUTPUT;
      } else if ((status | _ioffset) == _ioffset) {
        return INPUT;
      } else {
        return -1;
      }
    }

    uint8_t getState() {
      uint8_t status = *_PORT;
      if ((status & _offset) == _offset) {
        return HIGH;
      } else if ((status | _ioffset) == _ioffset) {
        return LOW;
      } else {
        return -1;
      }
    }

    uint8_t getValue() {
      uint8_t status = *_PIN;
      if ((status & _offset) == _offset) {
        return HIGH;
      } else if ((status | _ioffset) == _ioffset) {
        return LOW;
      } else {
        return -1;
      }
    }

    bool isValid() {
      return _valid;
    }

    void set(uint8_t mode, uint8_t state) {
      uint8_t oldSREG = SREG;
      cli();
      if (mode == INPUT) {
        DDR_LOW;
      } else {
        DDR_HIGH;
      }
      if (state == LOW) {
        PORT_LOW;
      } else {
        PORT_HIGH;
      }
      SREG = oldSREG;
    }

    void setMode(uint8_t mode) {
      uint8_t oldSREG = SREG;
      cli();
      if (mode == INPUT) {
        DDR_LOW;
      } else {
        DDR_HIGH;
      }
      SREG = oldSREG;
    }

    void setState(uint8_t state) {
      uint8_t oldSREG = SREG;
      cli();
      if (state == LOW) {
        PORT_LOW;
      } else {
        PORT_HIGH;
      }
      SREG = oldSREG;
    }

    void setInput() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_LOW;
      SREG = oldSREG;
    }

    void setPullupOn() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_HIGH;
      SREG = oldSREG;
    }

    void setPullupOff() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_LOW;
      SREG = oldSREG;
    }

    void setInputPullupOn() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_LOW;
      PORT_HIGH;
      SREG = oldSREG;
    }

    void setInputPullupOff() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_LOW;
      PORT_LOW;
      SREG = oldSREG;
    }

    void setOutput() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_HIGH;
      SREG = oldSREG;
    }

    void setHigh() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_HIGH;
      SREG = oldSREG;
    }

    void setLow() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_LOW;
      SREG = oldSREG;
    }

    void setOutputHigh() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_HIGH;
      PORT_HIGH;
      SREG = oldSREG;
    }

    void setOutputLow() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_HIGH;
      PORT_LOW;
      SREG = oldSREG;
    }

    void toggleMode() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_TOGGLE;
      SREG = oldSREG;
    }

    void toggleState() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_TOGGLE;
      SREG = oldSREG;
    }

  private:
    uint8_t _numbers[8];
    uint8_t _offset;
    uint8_t _ioffset;
    bool _valid;
    volatile uint8_t* _PIN;
    volatile uint8_t* _PORT;
    volatile uint8_t* _DDR;
};