| #pragma once |
| #include <gpioplus/chip.hpp> |
| #include <gpioplus/internal/fd.hpp> |
| |
| #include <cstdint> |
| #include <string_view> |
| #include <vector> |
| |
| namespace gpioplus |
| { |
| |
| /** @brief Flags to set when taking a handle */ |
| struct HandleFlags |
| { |
| /** @brief Is the line used for output (otherwise input) */ |
| bool output; |
| /** @brief Is the line value active at low voltage */ |
| bool active_low; |
| /** @brief Is the line an open drain */ |
| bool open_drain; |
| /** @brief Is the line an open source */ |
| bool open_source; |
| |
| HandleFlags() = default; |
| |
| /** @brief Creates handle flags from the gpio line flags |
| * |
| * @param[in] line_flags - Line flags used for population |
| */ |
| explicit HandleFlags(LineFlags line_flags); |
| |
| /** @brief Converts this struct to an int bitfield |
| * |
| * @return The int bitfield usable by the syscall interface |
| */ |
| uint32_t toInt() const; |
| }; |
| |
| /** @class HandleInterface |
| * @brief Handle interface to provide a set of methods required to exist in |
| * derived objects. |
| */ |
| class HandleInterface |
| { |
| public: |
| virtual ~HandleInterface() = default; |
| |
| virtual std::vector<uint8_t> getValues() const = 0; |
| virtual void getValues(std::vector<uint8_t>& values) const = 0; |
| virtual void setValues(const std::vector<uint8_t>& values) const = 0; |
| }; |
| |
| /** @class Handle |
| * @brief Handle to a gpio line handle |
| * @details Provides a c++ interface for gpio handle operations |
| */ |
| class Handle : public HandleInterface |
| { |
| public: |
| /** @brief Per line information used to construct a handle */ |
| struct Line |
| { |
| /** @brief Offset of the line on the gpio chip */ |
| uint32_t offset; |
| /** @brief Default output value of the line */ |
| uint8_t default_value; |
| }; |
| |
| /** @brief Creates a new gpio handle |
| * The underlying implementation of the handle is independent of |
| * the provided chip object. It is safe to destroy any of the |
| * provided inputs while this handle is alive. |
| * |
| * @param[in] chip - The gpio chip which provides the handle |
| * @param[in] lines - A collection of lines the handle provides |
| * @param[in] flags - The flags applied to all lines |
| * @param[in] consumer_label - The functional name of this consumer |
| * @throws std::system_error for underlying syscall failures |
| */ |
| Handle(const Chip& chip, const std::vector<Line>& lines, HandleFlags flags, |
| std::string_view consumer_label); |
| |
| /** @brief Get the file descriptor used for the handle |
| * |
| * @return The gpio handle file descriptor |
| */ |
| const internal::Fd& getFd() const; |
| |
| /** @brief Get the current values of all associated lines |
| * |
| * @throws std::system_error for underlying syscall failures |
| * @return The values of the gpio lines |
| */ |
| std::vector<uint8_t> getValues() const override; |
| |
| /** @brief Gets the current values of all associated lines |
| * |
| * @param[out] values - The values of the gpio lines |
| * @throws std::system_error for underlying syscall failures |
| */ |
| void getValues(std::vector<uint8_t>& values) const override; |
| |
| /** @brief Sets the current values of all associated lines |
| * |
| * @param[in] values - The new values of the gpio lines |
| * @throws std::system_error for underlying syscall failures |
| */ |
| void setValues(const std::vector<uint8_t>& values) const override; |
| |
| private: |
| internal::Fd fd; |
| uint32_t nlines; |
| }; |
| |
| } // namespace gpioplus |