gpiod.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * This file is part of libgpiod.
 *
 * Copyright (C) 2017-2018 Bartosz Golaszewski <bartekgola@gmail.com>
 */
 
#ifndef __LIBGPIOD_GPIOD_CXX_HPP__
#define __LIBGPIOD_GPIOD_CXX_HPP__
 
#include <bitset>
#include <chrono>
#include <gpiod.h>
#include <memory>
#include <string>
#include <vector>
 
namespace gpiod {
 
class line;
class line_bulk;
class line_iter;
class chip_iter;
struct line_event;
 
class chip
{
public:
 
        GPIOD_API chip(void) = default;
 
        GPIOD_API chip(const ::std::string& device, int how = OPEN_LOOKUP);
 
        GPIOD_API chip(const chip& other) = default;
 
        GPIOD_API chip(chip&& other) = default;
 
        GPIOD_API chip& operator=(const chip& other) = default;
 
        GPIOD_API chip& operator=(chip&& other) = default;
 
        GPIOD_API ~chip(void) = default;
 
        GPIOD_API void open(const ::std::string &device, int how = OPEN_LOOKUP);
 
        GPIOD_API void reset(void) noexcept;
 
        GPIOD_API ::std::string name(void) const;
 
        GPIOD_API ::std::string label(void) const;
 
        GPIOD_API unsigned int num_lines(void) const;
 
        GPIOD_API line get_line(unsigned int offset) const;
 
        GPIOD_API line find_line(const ::std::string& name) const;
 
        GPIOD_API line_bulk get_lines(const ::std::vector<unsigned int>& offsets) const;
 
        GPIOD_API line_bulk get_all_lines(void) const;
 
        GPIOD_API line_bulk find_lines(const ::std::vector<::std::string>& names) const;
 
        GPIOD_API bool operator==(const chip& rhs) const noexcept;
 
        GPIOD_API bool operator!=(const chip& rhs) const noexcept;
 
        GPIOD_API explicit operator bool(void) const noexcept;
 
        GPIOD_API bool operator!(void) const noexcept;
 
        enum : int {
                OPEN_LOOKUP = 1,
                OPEN_BY_PATH,
                OPEN_BY_NAME,
                OPEN_BY_LABEL,
                OPEN_BY_NUMBER,
        };
 
private:
 
        chip(::gpiod_chip* chip);
 
        void throw_if_noref(void) const;
 
        ::std::shared_ptr<::gpiod_chip> _m_chip;
 
        friend chip_iter;
        friend line_iter;
};
 
struct line_request
{
        enum : int {
                DIRECTION_AS_IS = 1,
                DIRECTION_INPUT,
                DIRECTION_OUTPUT,
                EVENT_FALLING_EDGE,
                EVENT_RISING_EDGE,
                EVENT_BOTH_EDGES,
        };
 
        GPIOD_API static const ::std::bitset<32> FLAG_ACTIVE_LOW;
        GPIOD_API static const ::std::bitset<32> FLAG_OPEN_SOURCE;
        GPIOD_API static const ::std::bitset<32> FLAG_OPEN_DRAIN;
        GPIOD_API static const ::std::bitset<32> FLAG_BIAS_DISABLE;
        GPIOD_API static const ::std::bitset<32> FLAG_BIAS_PULL_DOWN;
        GPIOD_API static const ::std::bitset<32> FLAG_BIAS_PULL_UP;
        ::std::string consumer;
        int request_type;
        ::std::bitset<32> flags;
};
 
class line
{
public:
 
        GPIOD_API line(void);
 
        GPIOD_API line(const line& other) = default;
 
        GPIOD_API line(line&& other) = default;
 
        GPIOD_API line& operator=(const line& other) = default;
 
        GPIOD_API line& operator=(line&& other) = default;
 
        GPIOD_API ~line(void) = default;
 
        GPIOD_API unsigned int offset(void) const;
 
        GPIOD_API ::std::string name(void) const;
 
        GPIOD_API ::std::string consumer(void) const;
 
        GPIOD_API int direction(void) const;
 
        GPIOD_API int active_state(void) const;
 
        GPIOD_API int bias(void) const;
 
        GPIOD_API bool is_used(void) const;
 
        GPIOD_API bool is_open_drain(void) const;
 
        GPIOD_API bool is_open_source(void) const;
 
        GPIOD_API void request(const line_request& config, int default_val = 0) const;
 
        GPIOD_API void release(void) const;
 
        GPIOD_API bool is_requested(void) const;
 
        GPIOD_API int get_value(void) const;
 
        GPIOD_API void set_value(int val) const;
 
        GPIOD_API void set_config(int direction, ::std::bitset<32> flags,
                                  int value = 0) const;
 
        GPIOD_API void set_flags(::std::bitset<32> flags) const;
 
        GPIOD_API void set_direction_input() const;
 
        GPIOD_API void set_direction_output(int value = 0) const;
 
        GPIOD_API bool event_wait(const ::std::chrono::nanoseconds& timeout) const;
 
        GPIOD_API line_event event_read(void) const;
 
        GPIOD_API ::std::vector<line_event> event_read_multiple(void) const;
 
        GPIOD_API int event_get_fd(void) const;
 
        GPIOD_API const chip& get_chip(void) const;
 
        GPIOD_API void update(void) const;
 
        GPIOD_API void reset(void);
 
        GPIOD_API bool operator==(const line& rhs) const noexcept;
 
        GPIOD_API bool operator!=(const line& rhs) const noexcept;
 
        GPIOD_API explicit operator bool(void) const noexcept;
 
        GPIOD_API bool operator!(void) const noexcept;
 
        enum : int {
                DIRECTION_INPUT = 1,
                DIRECTION_OUTPUT,
        };
 
        enum : int {
                ACTIVE_LOW = 1,
                ACTIVE_HIGH,
        };
 
        enum : int {
                BIAS_AS_IS = 1,
                BIAS_DISABLE,
                BIAS_PULL_UP,
                BIAS_PULL_DOWN,
        };
 
private:
 
        line(::gpiod_line* line, const chip& owner);
 
        void throw_if_null(void) const;
        line_event make_line_event(const ::gpiod_line_event& event) const noexcept;
 
        ::gpiod_line* _m_line;
        chip _m_chip;
 
        friend chip;
        friend line_bulk;
        friend line_iter;
};
 
GPIOD_API line find_line(const ::std::string& name);
 
struct line_event
{
        enum : int {
                RISING_EDGE = 1,
                FALLING_EDGE,
        };
 
        ::std::chrono::nanoseconds timestamp;
        int event_type;
        line source;
};
 
class line_bulk
{
public:
 
        GPIOD_API line_bulk(void) = default;
 
        GPIOD_API line_bulk(const ::std::vector<line>& lines);
 
        GPIOD_API line_bulk(const line_bulk& other) = default;
 
        GPIOD_API line_bulk(line_bulk&& other) = default;
 
        GPIOD_API line_bulk& operator=(const line_bulk& other) = default;
 
        GPIOD_API line_bulk& operator=(line_bulk&& other) = default;
 
        GPIOD_API ~line_bulk(void) = default;
 
        GPIOD_API void append(const line& new_line);
 
        GPIOD_API line& get(unsigned int offset);
 
        GPIOD_API line& operator[](unsigned int offset);
 
        GPIOD_API unsigned int size(void) const noexcept;
 
        GPIOD_API bool empty(void) const noexcept;
 
        GPIOD_API void clear(void);
 
        GPIOD_API void request(const line_request& config,
                               const ::std::vector<int> default_vals = ::std::vector<int>()) const;
 
        GPIOD_API void release(void) const;
 
        GPIOD_API ::std::vector<int> get_values(void) const;
 
        GPIOD_API void set_values(const ::std::vector<int>& values) const;
 
        GPIOD_API void set_config(int direction, ::std::bitset<32> flags,
                                  const ::std::vector<int> values = ::std::vector<int>()) const;
 
        GPIOD_API void set_flags(::std::bitset<32> flags) const;
 
        GPIOD_API void set_direction_input() const;
 
        GPIOD_API void set_direction_output(const ::std::vector<int>& values) const;
 
        GPIOD_API line_bulk event_wait(const ::std::chrono::nanoseconds& timeout) const;
 
        GPIOD_API explicit operator bool(void) const noexcept;
 
        GPIOD_API bool operator!(void) const noexcept;
 
        GPIOD_API static const unsigned int MAX_LINES;
 
        class iterator
        {
        public:
 
                GPIOD_API iterator(void) = default;
 
                GPIOD_API iterator(const iterator& other) = default;
 
                GPIOD_API iterator(iterator&& other) = default;
 
                GPIOD_API iterator& operator=(const iterator& other) = default;
 
                GPIOD_API iterator& operator=(iterator&& other) = default;
 
                GPIOD_API ~iterator(void) = default;
 
                GPIOD_API iterator& operator++(void);
 
                GPIOD_API const line& operator*(void) const;
 
                GPIOD_API const line* operator->(void) const;
 
                GPIOD_API bool operator==(const iterator& rhs) const noexcept;
 
                GPIOD_API bool operator!=(const iterator& rhs) const noexcept;
 
        private:
 
                iterator(const ::std::vector<line>::iterator& it);
 
                ::std::vector<line>::iterator _m_iter;
 
                friend line_bulk;
        };
 
        GPIOD_API iterator begin(void) noexcept;
 
        GPIOD_API iterator end(void) noexcept;
 
private:
 
        void throw_if_empty(void) const;
        void to_line_bulk(::gpiod_line_bulk* bulk) const;
 
        ::std::vector<line> _m_bulk;
};
 
GPIOD_API chip_iter make_chip_iter(void);
 
GPIOD_API chip_iter begin(chip_iter iter) noexcept;
 
GPIOD_API chip_iter end(const chip_iter& iter) noexcept;
 
class chip_iter
{
public:
 
        GPIOD_API chip_iter(void) = default;
 
        GPIOD_API chip_iter(const chip_iter& other) = default;
 
        GPIOD_API chip_iter(chip_iter&& other) = default;
 
        GPIOD_API chip_iter& operator=(const chip_iter& other) = default;
 
        GPIOD_API chip_iter& operator=(chip_iter&& other) = default;
 
        GPIOD_API ~chip_iter(void) = default;
 
        GPIOD_API chip_iter& operator++(void);
 
        GPIOD_API const chip& operator*(void) const;
 
        GPIOD_API const chip* operator->(void) const;
 
        GPIOD_API bool operator==(const chip_iter& rhs) const noexcept;
 
        GPIOD_API bool operator!=(const chip_iter& rhs) const noexcept;
 
private:
 
        chip_iter(::gpiod_chip_iter* iter);
 
        ::std::shared_ptr<::gpiod_chip_iter> _m_iter;
        chip _m_current;
 
        friend chip_iter make_chip_iter(void);
};
 
GPIOD_API line_iter begin(line_iter iter) noexcept;
 
GPIOD_API line_iter end(const line_iter& iter) noexcept;
 
class line_iter
{
public:
 
        GPIOD_API line_iter(void) = default;
 
        GPIOD_API line_iter(const chip& owner);
 
        GPIOD_API line_iter(const line_iter& other) = default;
 
        GPIOD_API line_iter(line_iter&& other) = default;
 
        GPIOD_API line_iter& operator=(const line_iter& other) = default;
 
        GPIOD_API line_iter& operator=(line_iter&& other) = default;
 
        GPIOD_API ~line_iter(void) = default;
 
        GPIOD_API line_iter& operator++(void);
 
        GPIOD_API const line& operator*(void) const;
 
        GPIOD_API const line* operator->(void) const;
 
        GPIOD_API bool operator==(const line_iter& rhs) const noexcept;
 
        GPIOD_API bool operator!=(const line_iter& rhs) const noexcept;
 
private:
 
        ::std::shared_ptr<::gpiod_line_iter> _m_iter;
        line _m_current;
};
 
} /* namespace gpiod */
 
#endif /* __LIBGPIOD_GPIOD_CXX_HPP__ */