gpio.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2015-2019 Peter A. Bigot */
 
#ifndef NRFCXX_GPIO_HPP
#define NRFCXX_GPIO_HPP
#pragma once
 
#include <nrfcxx/impl.hpp>
 
namespace nrfcxx {
 
namespace gpio {
 
constexpr uint32_t PIN_CNF_RDONLY = ((GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)
                                     | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos)
                                     | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos)
                                     | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos));
 
constexpr uint32_t PIN_CNF_WRONLY = ((GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)
                                     | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos)
                                     | (GPIO_PIN_CNF_INPUT_Disconnect << GPIO_PIN_CNF_INPUT_Pos)
                                     | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos));
 
constexpr uint32_t PIN_CNF_RDWR = ((GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)
                                   | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos)
                                   | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos)
                                   | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos));
 
constexpr uint32_t PIN_CNF_PWRUP = ((GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)
                                    | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos)
                                    | (GPIO_PIN_CNF_INPUT_Disconnect << GPIO_PIN_CNF_INPUT_Pos)
                                    | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos));
 
constexpr uint32_t PIN_CNF_PULLUP = (GPIO_PIN_CNF_PULL_Pullup << GPIO_PIN_CNF_PULL_Pos);
 
constexpr uint32_t PIN_CNF_PULLDOWN = (GPIO_PIN_CNF_PULL_Pulldown << GPIO_PIN_CNF_PULL_Pos);
 
constexpr uint32_t PIN_CNF_ACTIVE_LOW_NOPULL = (PIN_CNF_RDONLY
                                                | (GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos));
 
constexpr uint32_t PIN_CNF_ACTIVE_LOW = (PIN_CNF_ACTIVE_LOW_NOPULL | PIN_CNF_PULLUP);
 
constexpr uint32_t PIN_CNF_ACTIVE_HIGH_NOPULL = (PIN_CNF_RDONLY
                                                 | (GPIO_PIN_CNF_SENSE_High << GPIO_PIN_CNF_SENSE_Pos));
 
constexpr uint32_t PIN_CNF_ACTIVE_HIGH = (PIN_CNF_ACTIVE_HIGH_NOPULL | PIN_CNF_PULLDOWN);
 
static constexpr int instance_for_psel (int psel)
{
  if ((nrf5::GPIO_Instance<0>::begin_psel <= psel)
      && (psel < nrf5::GPIO_Instance<0>::end_psel)) {
    return 0;
  }
#if (NRF52840 - 0)
  if ((nrf5::GPIO_Instance<1>::begin_psel <= psel)
      && (psel < nrf5::GPIO_Instance<1>::end_psel)) {
    return 1;
  }
#endif
  return -1;
}
 
template <int PSEL>
class instr_psel
{
  using GPIO_Instance = nrf5::GPIO_Instance<PSEL / 32>;
 
public:
  using this_type = instr_psel<PSEL>;
 
  constexpr static int global_psel = PSEL;
 
  constexpr static uint8_t psel = (PSEL - GPIO_Instance::begin_psel);
 
  constexpr static uint8_t gpio_instance = GPIO_Instance::peripheral.INSTANCE;
 
  constexpr static nrf5::GPIO_Type gpio = GPIO_Instance::peripheral;
 
  constexpr static bool psel_valid = (0 <= PSEL) && (psel < gpio.AUX);
 
  constexpr static uint32_t bit = (psel_valid ? (1U << psel) : 0);
  /* No-op constructor and destructor, as these objects are generally
   * statically allocated in an anonymous namespace.  This means the
   * application must enable() them explicitly. */
  instr_psel ()
  { }
 
  ~instr_psel ()
  { }
 
  /* No copying or moving these things */
  instr_psel (const instr_psel&) = delete;
  instr_psel& operator= (const instr_psel&) = delete;
  instr_psel (instr_psel&&) = delete;
  instr_psel& operator= (instr_psel&&) = delete;
 
  void enable (bool set = false) const
  {
    if (psel_valid) {
      if (set) {
        gpio->OUTSET = bit;
      } else {
        gpio->OUTCLR = bit;
      }
      gpio->PIN_CNF[psel] = PIN_CNF_WRONLY;
    }
  }
 
  void disable () const
  {
    if (psel_valid) {
      gpio->PIN_CNF[psel] = PIN_CNF_PWRUP;
    }
  }
 
  void assert () const
  {
    if (psel_valid) {
      gpio->OUTSET = bit;
    }
  }
 
  void deassert () const
  {
    if (psel_valid) {
      gpio->OUTCLR = bit;
    }
  }
 
  void set (bool asserted) const
  {
    if (psel_valid) {
      if (asserted) {
        gpio->OUTSET = bit;
      } else {
        gpio->OUTCLR = bit;
      }
    }
  }
 
  void toggle () const
  {
    if (psel_valid) {
      if (gpio->OUT & bit) {
        gpio->OUTCLR = bit;
      } else {
        gpio->OUTSET = bit;
      }
    }
  }
 
};
 
template <typename INSTR_PSEL>
class instr_psel_scoped
{
public:
  using instr_psel_type = INSTR_PSEL;
 
  constexpr instr_psel_scoped (const instr_psel_type& instance_,
                               bool start_set) :
    instance{instance_}
  {
    instance.enable(start_set);
  }
 
  ~instr_psel_scoped ()
  {
    instance.deassert();
    instance.disable();
  }
 
  /* You can't copy or assign scoped instances but you can
   * move-construct them. */
  instr_psel_scoped (const instr_psel_scoped&) = delete;
  instr_psel_scoped& operator= (const instr_psel_scoped&) = delete;
  instr_psel_scoped (instr_psel_scoped&&) = default;
  instr_psel_scoped& operator= (instr_psel_scoped&&) = delete;
 
  void assert () const
  {
    instance.assert();
  }
 
  void deassert () const
  {
    instance.deassert();
  }
 
  void set (bool asserted) const
  {
    instance.set(asserted);
  }
 
  void toggle () const
  {
    instance.toggle();
  }
 
  const instr_psel_type& instance;
};
 
template <typename INSTR_PSEL>
instr_psel_scoped<INSTR_PSEL>
make_scoped_instr (const INSTR_PSEL& instance,
                   bool start_set = true)
{
  return {instance, start_set};
}
 
class pin_reference
{
public:
  uint8_t const global_psel;
 
  uint8_t const local_psel;
 
  uint32_t const local_bit;
 
  const nrf5::GPIO_Type &peripheral;
 
  static pin_reference create (int psel);
 
  void set () const
  {
    peripheral->OUTSET = local_bit;
  }
 
  void clear () const
  {
    peripheral->OUTCLR = local_bit;
  }
 
  void toggle () const
  {
    if (is_set()) {
      clear();
    } else {
      set();
    }
  }
 
  uint32_t configuration () const
  {
    return peripheral->PIN_CNF[local_psel];
  }
 
  void configure (uint32_t pin_cnf) const
  {
    peripheral->PIN_CNF[local_psel] = pin_cnf;
  }
 
  bool read () const
  {
    return local_bit & peripheral->IN;
  }
 
  bool is_set () const
  {
    return (local_bit & peripheral->OUT);
  }
 
private:
  pin_reference (const nrf5::GPIO_Type& peripheral,
                 int psel,
                 int begin_psel);
};
 
class generic_pin
{
public:
  generic_pin () = default;
  virtual ~generic_pin () = default;
 
  virtual bool valid () const
  {
    return false;
  }
 
  virtual void set ()
  { }
 
  virtual void clear ()
  { }
 
  virtual void toggle ()
  { }
 
  virtual void configure (unsigned int pin_cnf)
  { }
 
  virtual unsigned int configuration () const
  {
    return 0;
  }
 
  virtual bool read () const
  {
    return false;
  }
 
  virtual bool is_set () const
  {
    return false;
  }
};
 
class gpio_pin : public generic_pin
{
public:
  gpio_pin (int psel) :
    pr_{pin_reference::create(psel)}
  { }
 
  const pin_reference& implementation () const
  {
    return pr_;
  }
 
  bool valid () const override
  {
    return true;
  }
 
  void set () override
  {
    pr_.set();
  }
 
  void clear () override
  {
    pr_.clear();
  }
 
  void toggle () override
  {
    pr_.toggle();
  }
 
  unsigned int configuration () const override
  {
    return pr_.configuration();
  }
 
  void configure (unsigned int pin_cnf) override
  {
    pr_.configure(pin_cnf);
  }
 
  bool read () const override
  {
    return pr_.read();
  }
 
  bool is_set () const override
  {
    return pr_.is_set();
  }
 
private:
  pin_reference pr_;
};
 
template <bool ACTIVE_HIGH = false>
class active_signal
{
public:
  static constexpr bool active_high = ACTIVE_HIGH;
  using this_type = active_signal<active_high>;
 
  generic_pin& pin;
 
  struct scoped_assert
  {
    ~scoped_assert ()
    {
      al_.deassert();
    }
 
  private:
    friend this_type;
 
    scoped_assert (const this_type& al) :
      al_{al}
    {
      al_.assert();
    }
 
    const this_type& al_;
  };
 
  scoped_assert make_scoped () const
  {
    return scoped_assert{*this};
  }
 
  active_signal (generic_pin& pin) :
    pin{pin}
  {
    deassert();
  }
 
  bool valid () const
  {
    return true;
  }
 
  bool asserted () const
  {
    return active_high == pin.is_set();
  }
 
  void assert () const
  {
    return active_high ? pin.set() : pin.clear();
  }
 
  void deassert () const
  {
    return active_high ? pin.clear() : pin.set();
  }
 
  void enable (unsigned int aux = 0) const
  {
    pin.configure(PIN_CNF_WRONLY | aux);
  }
 
  void disable () const
  {
    pin.configure(PIN_CNF_PWRUP);
  }
};
 
using active_low = active_signal<false>;
 
inline
constexpr
uint32_t
pin_config (unsigned int dir = GPIO_PIN_CNF_DIR_Input,
            unsigned int input = GPIO_PIN_CNF_INPUT_Disconnect,
            unsigned int pull = GPIO_PIN_CNF_PULL_Disabled,
            unsigned int drive = GPIO_PIN_CNF_DRIVE_S0S1,
            unsigned int sense = GPIO_PIN_CNF_SENSE_Disabled)
{
  return (GPIO_PIN_CNF_DIR_Msk & (dir << GPIO_PIN_CNF_DIR_Pos))
    | (GPIO_PIN_CNF_INPUT_Msk & (input << GPIO_PIN_CNF_INPUT_Pos))
    | (GPIO_PIN_CNF_PULL_Msk & (input << GPIO_PIN_CNF_PULL_Pos))
    | (GPIO_PIN_CNF_DRIVE_Msk & (input << GPIO_PIN_CNF_DRIVE_Pos))
    | (GPIO_PIN_CNF_SENSE_Msk & (input << GPIO_PIN_CNF_SENSE_Pos));
}
 
template <typename mutex_type = null_mutex>
void
clear_sense (unsigned int psel)
{
  mutex_type mutex;
 
  const uint32_t pin_cnf = nrf5::GPIO->PIN_CNF[psel];
  nrf5::GPIO->PIN_CNF[psel] = pin_cnf & ~GPIO_PIN_CNF_SENSE_Msk;
}
 
unsigned int
update_sense_bi (unsigned int psel,
                 bool assume_change = false);
 
} // namespace gpio
} // namespace nrfcxx
 
#endif /* NRFCXX_GPIO_HPP */