RADDevice.h

Go to the documentation of this file.

#ifndef RADDEVICE_H
#define RADDEVICE_H
 
#pragma once
 
#include <RADCore/RADCore.h>
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace RADDevice {
 
    struct DevicePaths {
        std::string sysClassGpio = "/sys/class/gpio";
        std::string sysClassPwm = "/sys/class/pwm";
        std::string sysBusIio = "/sys/bus/iio/devices";
        std::string sysClassLeds = "/sys/class/leds";
        std::string devRoot = "/dev";
    };
 
    enum class GpioDirection {
        In,
        Out
    };
 
    enum class GpioEdge {
        None,
        Rising,
        Falling,
        Both
    };
 
    class I2CDevice {
    public:
        I2CDevice();
        ~I2CDevice();
        bool open(int bus, int address, const DevicePaths& paths = {}, std::string* error = nullptr);
        void close();
        ssize_t write(const std::vector<uint8_t>& bytes);
        std::vector<uint8_t> read(size_t count);
        bool isOpen() const;
        int fd() const;
 
    private:
        int fd_ = -1;
    };
 
    class SPIDevice {
    public:
        SPIDevice();
        ~SPIDevice();
        bool open(int bus, int chipSelect, const DevicePaths& paths = {}, std::string* error = nullptr);
        void close();
        bool configure(uint8_t mode, uint8_t bitsPerWord, uint32_t speedHz, std::string* error = nullptr);
        std::vector<uint8_t> transfer(const std::vector<uint8_t>& tx, std::string* error = nullptr);
        bool isOpen() const;
        int fd() const;
 
    private:
        int fd_ = -1;
        uint32_t speedHz_ = 1000000;
        uint8_t bitsPerWord_ = 8;
    };
 
    class GpioPin {
    public:
        GpioPin(int number, DevicePaths paths = {});
        bool exportPin(std::string* error = nullptr) const;
        bool unexportPin(std::string* error = nullptr) const;
        bool setDirection(GpioDirection direction, std::string* error = nullptr) const;
        bool setEdge(GpioEdge edge, std::string* error = nullptr) const;
        bool writeValue(bool high, std::string* error = nullptr) const;
        RADCore::RADResult<bool> readValue() const;
        std::string pinPath() const;
 
    private:
        int number_;
        DevicePaths paths_;
    };
 
    class PwmChannel {
    public:
        PwmChannel(int chip, int channel, DevicePaths paths = {});
        bool exportChannel(std::string* error = nullptr) const;
        bool setEnabled(bool enabled, std::string* error = nullptr) const;
        bool setPeriodNs(uint64_t periodNs, std::string* error = nullptr) const;
        bool setDutyCycleNs(uint64_t dutyNs, std::string* error = nullptr) const;
        std::string channelPath() const;
 
    private:
        int chip_;
        int channel_;
        DevicePaths paths_;
    };
 
    class AdcChannel {
    public:
        AdcChannel(int device, int channel, DevicePaths paths = {});
        RADCore::RADResult<int> readRaw() const;
        RADCore::RADResult<double> readScale() const;
        RADCore::RADResult<double> readScaled() const;
 
    private:
        int device_;
        int channel_;
        DevicePaths paths_;
    };
 
    class Watchdog {
    public:
        Watchdog();
        ~Watchdog();
        bool open(int index = 0, const DevicePaths& paths = {}, std::string* error = nullptr);
        void close();
        bool keepAlive(std::string* error = nullptr);
        bool isOpen() const;
 
    private:
        int fd_ = -1;
    };
 
    class Led {
    public:
        Led(std::string name, DevicePaths paths = {});
        bool setBrightness(int brightness, std::string* error = nullptr) const;
        RADCore::RADResult<int> brightness() const;
        RADCore::RADResult<int> maxBrightness() const;
 
    private:
        std::string name_;
        DevicePaths paths_;
    };
 
    std::vector<std::string> listLeds(const DevicePaths& paths = {});
    std::vector<std::string> listIioDevices(const DevicePaths& paths = {});
 
} // namespace RADDevice
 
#endif