device.hpp

Go to the documentation of this file.

#pragma once
 
#include "epaper/core/errors.hpp"
#include "epaper/hal/gpio.hpp"
#include "epaper/hal/spi.hpp"
#include <cstdint>
#include <expected>
#include <gpiod.h>
#include <span>
#include <string>
#include <unordered_map>
 
namespace epaper {
 
class Pin {
public:
  constexpr explicit Pin(std::uint8_t pin_number) : pin_(pin_number) {}
 
  [[nodiscard]] constexpr auto number() const noexcept -> std::uint8_t { return pin_; }
 
private:
  std::uint8_t pin_;
};
 
struct DeviceConfig {
  std::string gpio_chip = "/dev/gpiochip0";  
  std::string spi_device = "/dev/spidev0.0"; 
  std::uint32_t spi_speed_hz = 1953125;      
};
 
struct PinConfig {
  unsigned int offset;
  bool is_output;
  enum gpiod_line_value initial_value;
};
 
class Device {
public:
  Device();
 
  explicit Device(DeviceConfig config);
 
  ~Device() noexcept;
 
  // Non-copyable, movable
  Device(const Device &) = delete;
  auto operator=(const Device &) -> Device & = delete;
 
  Device(Device &&other) noexcept;
 
  auto operator=(Device &&other) noexcept -> Device &;
 
  [[nodiscard]] auto init() -> std::expected<void, Error>;
 
  // Check if device is initialized
  [[nodiscard]] auto is_initialized() const noexcept -> bool;
 
  // GPIO operations
  auto set_pin_output(Pin pin) -> void;
  auto set_pin_input(Pin pin) -> void;
  auto write_pin(Pin pin, bool value) -> void;
  [[nodiscard]] auto read_pin(Pin pin) -> bool;
 
  // SPI operations
  auto spi_transfer(std::uint8_t value) const -> std::uint8_t;
  auto spi_write(std::span<const std::byte> data) const -> void;
 
  // Delay utilities
  static auto delay_ms(std::uint32_t milliseconds) -> void;
  static auto delay_us(std::uint32_t microseconds) -> void;
 
  struct Delay {
    static auto delay_ms(std::uint32_t ms) -> void { Device::delay_ms(ms); }
  };
 
  // -- HAL Adapters --
 
  class HalOutput {
  public:
    HalOutput(Device &dev, Pin pin) : dev_(&dev), pin_(pin) {}
    auto write(bool level) -> void { dev_->write_pin(pin_, level); }
 
  private:
    Device *dev_;
    Pin pin_;
  };
  static_assert(hal::DigitalOutput<HalOutput>);
 
  class HalInput {
  public:
    HalInput(Device &dev, Pin pin) : dev_(&dev), pin_(pin) {}
    auto read() -> bool { return dev_->read_pin(pin_); }
 
  private:
    Device *dev_;
    Pin pin_;
  };
  static_assert(hal::DigitalInput<HalInput>);
 
  class HalSpi {
  public:
    explicit HalSpi(Device &dev) : dev_(&dev) {}
    auto transfer(std::uint8_t byte) -> std::uint8_t { return dev_->spi_transfer(byte); }
    auto write(std::span<const std::byte> data) -> void { dev_->spi_write(data); }
 
  private:
    Device *dev_;
  };
  static_assert(hal::SpiBus<HalSpi>);
 
  // -- HAL Factory Methods --
 
  [[nodiscard]] auto get_output(Pin pin) -> HalOutput {
    set_pin_output(pin);
    return HalOutput(*this, pin);
  }
 
  [[nodiscard]] auto get_input(Pin pin) -> HalInput {
    set_pin_input(pin);
    return HalInput(*this, pin);
  }
 
  [[nodiscard]] auto get_spi() -> HalSpi { return HalSpi(*this); }
 
private:
  auto rebuild_line_request() -> bool;
  auto cleanup() noexcept -> void;
 
  struct gpiod_chip *chip_ = nullptr;
  struct gpiod_line_request *line_request_ = nullptr;
  std::unordered_map<std::uint8_t, PinConfig> pin_configs_;
  int spi_fd_ = -1;
  bool initialized_ = false;
  bool spi_initialized_ = false;
  DeviceConfig config_;
};
 
} // namespace epaper