GPIO.hh

Go to the documentation of this file.

#ifndef COSA_GPIO_HH
#define COSA_GPIO_HH

#include "Cosa/Types.h"

class GPIO {
public:
  enum Mode {
    OUTPUT_MODE,                // Output pin mode.
    INPUT_MODE,                 // Input pin mode.
    PULLUP_INPUT_MODE           // Input pin with pullup mode.
  };

  GPIO(Board::DigitalPin pin, Mode mode = INPUT_MODE, bool value = 0) :
    m_sfr(Board::SFR(pin)),
    m_mask(MASK(pin))
  {
    synchronized {
      if (mode == OUTPUT_MODE) {
        *DDR() |= m_mask;
      }
      else {
        *DDR() &= ~m_mask;
      }
      if (value || (mode == PULLUP_INPUT_MODE)) {
        *PORT() |= m_mask;
      }
      else {
        *PORT() &= ~m_mask;
      }
    }
  }

  void mode(Mode mode) const
    __attribute__((always_inline))
  {
    synchronized {
      if (mode == OUTPUT_MODE)
        *DDR() |= m_mask;
      else {
        *DDR() &= ~m_mask;
        if (mode == PULLUP_INPUT_MODE)
          *PORT() |= m_mask;
      }
    }
  }

  Mode mode() const
    __attribute__((always_inline))
  {
    if ((*DDR() & m_mask) != 0)
      return (OUTPUT_MODE);
    if ((*PORT() & m_mask) != 0)
      return (PULLUP_INPUT_MODE);
    return (INPUT_MODE);
  }

  operator bool() const
    __attribute__((always_inline))
  {
    return ((*PIN() & m_mask) != 0);
  }

  GPIO& operator=(bool value)
    __attribute__((always_inline))
  {
    synchronized {
      if (value) {
        *PORT() |= m_mask;
      }
      else {
        *PORT() &= ~m_mask;
      }
    }
    return (*this);
  }

  GPIO& operator=(const GPIO& rhs)
    __attribute__((always_inline))
  {
    bool value = rhs;
    synchronized {
      if (value) {
        *PORT() |= m_mask;
      }
      else {
        *PORT() &= ~m_mask;
      }
    }
    return (*this);
  }

  void operator~() const
    __attribute__((always_inline))
  {
    *PIN() = m_mask;
  }

  static void mode(Board::DigitalPin pin, Mode mode)
    __attribute__((always_inline))
  {
    const uint8_t mask = MASK(pin);
    synchronized {
      if (mode == OUTPUT_MODE)
        *DDR(pin) |= mask;
      else {
        *DDR(pin) &= ~mask;
        if (mode == PULLUP_INPUT_MODE)
          *PORT(pin) |= mask;
      }
    }
  }

  static Mode mode(Board::DigitalPin pin)
    __attribute__((always_inline))
  {
    const uint8_t mask = MASK(pin);
    if ((*DDR(pin) & mask) != 0)
      return (OUTPUT_MODE);
    if ((*PORT(pin) & mask) != 0)
      return (PULLUP_INPUT_MODE);
    return (INPUT_MODE);
  }

  static bool read(Board::DigitalPin pin)
    __attribute__((always_inline))
  {
    return ((*PIN(pin) & MASK(pin)) != 0);
  }

  static void write(Board::DigitalPin pin, bool value)
    __attribute__((always_inline))
  {
    volatile uint8_t* port = PORT(pin);
    const uint8_t mask = MASK(pin);
#if (ARDUINO > 150)
    // Synchronized not needed when constant values (and lower ports)
#if defined(PORTH)
    if (((int) port < PORTH)
        && __builtin_constant_p(pin)
        && __builtin_constant_p(value)) {
#else
    if (__builtin_constant_p(pin) && __builtin_constant_p(value)) {
#endif
      if (value) {
        *port |= mask;
      }
      else {
        *port &= ~mask;
      }
    }
    else
#endif
    synchronized {
      if (value) {
        *port |= mask;
      }
      else {
        *port &= ~mask;
      }
    }
  }

  static void toggle(Board::DigitalPin pin)
    __attribute__((always_inline))
  {
    volatile uint8_t* port = PIN(pin);
    const uint8_t mask = MASK(pin);
#if (ARDUINO > 150)
    // Synchronized not needed when constant values (and lower ports)
#if defined(PORTH)
    if (((int) port < PORTH) && __builtin_constant_p(pin))
#else
    if (__builtin_constant_p(pin))
#endif
      *port = mask;
    else
#endif
      synchronized {
        *port = mask;
      }
    }

protected:
  volatile uint8_t* const m_sfr;

  const uint8_t m_mask;

  volatile uint8_t* PIN() const
  {
    return (m_sfr);
  }

  volatile uint8_t* DDR() const
  {
    return (m_sfr + 1);
  }

  volatile uint8_t* PORT() const
  {
    return (m_sfr + 2);
  }

public:
  static uint8_t MASK(uint8_t pin)
    __attribute__((always_inline))
  {
    return (_BV(Board::BIT(pin)));
  }
  static volatile uint8_t* PIN(uint8_t pin)
    __attribute__((always_inline))
  {
    return (Board::SFR(pin));
  }

  static volatile uint8_t* DDR(uint8_t pin)
    __attribute__((always_inline))
  {
    return (Board::SFR(pin) + 1);
  }

  static volatile uint8_t* PORT(uint8_t pin)
    __attribute__((always_inline))
  {
    return (Board::SFR(pin) + 2);
  }
};

#endif