Gpio Class Reference

#include <bsp_gpio.hpp>

Public Types
using	Callback = std::function< void()>

Public Member Functions
	Gpio (const std::string &chip_name, unsigned int line_num, bool is_output, int default_value=1)
	~Gpio ()
void	Write (int value)
int	Read () const
void	EnableInterruptRisingEdgeWithCallback (Callback cb)

Private Member Functions
void	InterruptWaitLoop ()

Private Attributes
gpiod_chip *	chip_
gpiod_line *	line_ {}
unsigned int	line_num_
bool	is_output_
std::atomic< bool >	running_ {false}
std::thread	interrupt_thread_
Callback	callback_

Detailed Description

Gpio class

Handles GPIO initialization, configuration (input/output), read/write operations, and interrupt callback support.

Definition at line 19 of file bsp_gpio.hpp.

Member Typedef Documentation

Callback

using Gpio::Callback = std::function<void()>

Definition at line 21 of file bsp_gpio.hpp.

Constructor & Destructor Documentation

Gpio()

Gpio::Gpio ( const std::string &  chip_name, unsigned int  line_num, bool  is_output, int  default_value = 1  )

inline

Constructor

Parameters

chip_name	GPIO chip name, e.g., "gpiochip0"
line_num	GPIO line number
is_output	true for output mode, false for input mode
default_value	Initial value for output mode (default: 1)

Definition at line 31 of file bsp_gpio.hpp.

      : chip_(gpiod_chip_open_by_name(chip_name.c_str())),
        is_output_(is_output),
        line_num_(line_num) {
    assert(!chip_name.empty()); /* Ensure chip name is valid */
 
    if (!chip_) {
      std::perror("Failed to open GPIO chip");
    }
 
    line_ = gpiod_chip_get_line(chip_, line_num_);
    if (!line_) {
      gpiod_chip_close(chip_);
      std::perror("Failed to get GPIO line");
    }
 
    int ret = is_output_
                  ? gpiod_line_request_output(line_, nullptr, default_value)
                  : gpiod_line_request_input(line_, nullptr);
    if (ret < 0) {
      std::perror("Failed to configure GPIO line");
    }
  }

~Gpio()

Gpio::~Gpio ( )

inline

Destructor

Releases allocated resources and stops interrupt thread.

Definition at line 61 of file bsp_gpio.hpp.

          {
    running_ = false;
 
    if (interrupt_thread_.joinable()) {
      interrupt_thread_.join();
    }
 
    if (line_) {
      gpiod_line_release(line_);
    }
 
    if (chip_) {
      gpiod_chip_close(chip_);
    }
  }

Member Function Documentation

EnableInterruptRisingEdgeWithCallback()

void Gpio::EnableInterruptRisingEdgeWithCallback ( Callback  cb )

inline

Enable rising edge interrupt and register callback.

This starts a background thread to monitor GPIO events.

Parameters

cb	Callback function to be invoked on rising edge.

Definition at line 109 of file bsp_gpio.hpp.

                                                          {
    if (is_output_) {
      std::perror("Cannot register interrupt on output GPIO");
    }
 
    /* If line is already in use, release it */
    if (line_) {
      gpiod_line_release(line_);
    }
 
    /* Request GPIO line for interrupt events */
    if (gpiod_line_request_rising_edge_events(line_, nullptr) < 0) {
      std::perror("Failed to enable rising edge interrupt");
    }
 
    callback_ = std::move(cb);
    running_ = true;
 
    interrupt_thread_ = std::thread(&Gpio::InterruptWaitLoop, this);
  }

InterruptWaitLoop()

void Gpio::InterruptWaitLoop ( )

inlineprivate

Background thread loop that waits for GPIO rising edge events.

Definition at line 134 of file bsp_gpio.hpp.

                           {
    while (running_) {
      int ret = gpiod_line_event_wait(line_, nullptr);  // block until event
      if (ret == 1 && callback_) {
        struct gpiod_line_event event;
        if (gpiod_line_event_read(line_, &event) == 0 &&
            event.event_type == GPIOD_LINE_EVENT_RISING_EDGE) {
          callback_();
        }
      }
    }
  }

Read()

int Gpio::Read ( ) const

inline

Read the current GPIO value.

Returns

Current GPIO value (0 or 1)

Definition at line 94 of file bsp_gpio.hpp.

                   {
    int value = gpiod_line_get_value(line_);
    if (value < 0) {
      std::perror("GPIO read failed");
    }
    return value;
  }

Write()

void Gpio::Write ( int  value )

inline

Write a value to the GPIO line (only valid in output mode).

Parameters

value

Value to write (0 or 1)

Definition at line 82 of file bsp_gpio.hpp.

                        {
    assert(is_output_);
    if (gpiod_line_set_value(line_, value) < 0) {
      std::perror("GPIO write failed");
    }
  }

Field Documentation

callback_

Callback Gpio::callback_

private

Definition at line 154 of file bsp_gpio.hpp.

chip_

gpiod_chip* Gpio::chip_

private

Definition at line 147 of file bsp_gpio.hpp.

interrupt_thread_

std::thread Gpio::interrupt_thread_

private

Definition at line 153 of file bsp_gpio.hpp.

is_output_

bool Gpio::is_output_

private

Definition at line 150 of file bsp_gpio.hpp.

line_

gpiod_line* Gpio::line_ {}

private

Definition at line 148 of file bsp_gpio.hpp.

{};     // GPIO line handle

line_num_

unsigned int Gpio::line_num_

private

Definition at line 149 of file bsp_gpio.hpp.

running_

std::atomic<bool> Gpio::running_ {false}

private

Definition at line 152 of file bsp_gpio.hpp.

{false};  // Interrupt thread flag

---

The documentation for this class was generated from the following file:

• src/bsp/bsp_gpio.hpp