gpio.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
 
#pragma once
 
#include <fcntl.h>
#include <unistd.h>
 
#include <mutex>
#include <unordered_set>
 
namespace sol3::gpio {
 
using GpioPinId = uint32_t;
using GpioPinValue = uint32_t;
 
enum class GpioEdge {
  RISING,   
  FALLING,  
  BOTH      
};
 
struct GpioInputPinOptions {
  GpioEdge edge = GpioEdge::BOTH;
  bool active_low = false;
};
 
struct GpioEdgeEventResult {
  bool timeout = false;
  bool error = false;
  bool interrupted = false;
  GpioEdge edge = GpioEdge::RISING;
};
 
class GpioPinManager;
 
namespace impl {
class GpioPinBase {
 public:
  // Move-only semantics.
  GpioPinBase(GpioPinBase&& other) noexcept;
  GpioPinBase& operator=(GpioPinBase&& other) noexcept;
  GpioPinBase(GpioPinBase const&) = delete;
  GpioPinBase& operator=(GpioPinBase const&) = delete;
 
 protected:
  friend class GpioPinManager;
 
  ~GpioPinBase();
 
  GpioPinBase(GpioPinId pin, GpioPinManager* manager, int value_fd);
 
  GpioPinId pin_;
  GpioPinManager* manager_;
  int value_fd_;
};
}  // namespace impl
 
class GpioInputPin : public impl::GpioPinBase {
 public:
  ~GpioInputPin() = default;
 
  GpioPinValue read() const;
 
  GpioEdgeEventResult waitForEdgeEvent(std::chrono::milliseconds timeout) const;
 
  GpioInputPinOptions const& getOptions() const { return options_; }
 
  // Move-only semantics.
  GpioInputPin(GpioInputPin&& other) noexcept = default;
  GpioInputPin& operator=(GpioInputPin&& other) noexcept = default;
  GpioInputPin(GpioInputPin const& other) noexcept = delete;
  GpioInputPin& operator=(GpioInputPin& other) noexcept = delete;
 
 private:
  friend class GpioPinManager;
 
  GpioInputPin(
      GpioPinId pin,
      GpioPinManager* manager,
      GpioInputPinOptions const& options);
 
  GpioInputPinOptions options_;
};
 
class GpioOutputPin : public impl::GpioPinBase {
 public:
  ~GpioOutputPin() = default;
 
  void write(GpioPinValue value);
 
  // Move-only semantics.
  GpioOutputPin(GpioOutputPin&& other) noexcept = default;
  GpioOutputPin& operator=(GpioOutputPin&& other) noexcept = default;
  GpioOutputPin(GpioOutputPin const& other) noexcept = delete;
  GpioOutputPin& operator=(GpioOutputPin const& other) noexcept = delete;
 
 private:
  friend class GpioPinManager;
 
  GpioOutputPin(GpioPinId pin, GpioPinManager* manager);
};
 
class GpioPinManager {
 public:
  static GpioPinManager& getInstance() {
    static GpioPinManager s_instance;
    return s_instance;
  }
 
  template <typename TPin>
  GpioInputPin acquireInputPin(
      TPin pin, GpioInputPinOptions const& options = {}) {
    return GpioInputPin(static_cast<GpioPinId>(pin), this, options);
  }
 
  template <typename TPin>
  GpioOutputPin acquireOutputPin(TPin pin) {
    return GpioOutputPin(static_cast<GpioPinId>(pin), this);
  }
 
  // Non-copyable, non-movable
  GpioPinManager(GpioPinManager const&) = delete;
  GpioPinManager& operator=(GpioPinManager const&) = delete;
  GpioPinManager(GpioPinManager&&) = delete;
  GpioPinManager& operator=(GpioPinManager&&) = delete;
 
 private:
  friend class impl::GpioPinBase;
 
  GpioPinManager() = default;
  ~GpioPinManager() = default;
 
  // Reserve the pin for configuration. Called in the constructor of GpioPinBase
  void reservePin(GpioPinId pin);
 
  // Release a reserved pin. Called in the destructor of GpioPinBase.
  void releasePin(GpioPinId pin);
 
  mutable std::mutex mutex_;
  std::unordered_set<GpioPinId> reserved_pins_;
};
 
enum class Pin : GpioPinId {
  // Carrier ADC Chipselects
  CARRIER_ADC1_CS = 20,
  CARRIER_ADC2_CS = 21,
  CARRIER_ADC3_CS = 32,
  // SPI
  MISO = 52,
  MOSI = 53,
  SCLK = 54,
  // Power ADC Chipselect
  POWER_ADC_CS = 55,
  // External trigger
  EXTTRIG = 60,
  // Self reset
  SELF_RESET = 122,
  // Shift Register
  SER_FB = 137,
  SER = 142,
  SRCLK = 143,
  RCLK = 144,
  SR_OE = 145,
  // Deserializer PMIC Enable
  DES_PMIC_EN = 152,
};
 
}  // namespace sol3::gpio