board.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <string>
#include <unordered_map>
 
#include <viam/sdk/common/proto_value.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/config/resource.hpp>
 
namespace viam {
namespace sdk {
 
class Board : public Component {
   public:
    using analog_value = int32_t;
 
    struct analog_response {
        analog_value value;
        float min_range;  // Minimum possible voltage read by the analog reader
        float max_range;  // Maximum possible voltage read by the analog reader
        float step_size;  // Volts represented in each step in the value
    };
 
    using digital_value = int64_t;
 
    struct status {
        std::unordered_map<std::string, analog_value> analog_reader_values;
        std::unordered_map<std::string, digital_value> digital_interrupt_values;
    };
 
    struct Tick {
        std::string pin_name;
 
        std::chrono::nanoseconds time;
 
        bool high;
    };
 
    enum class power_mode : uint8_t { normal = 0, offline_deep = 1 };
 
    API api() const override;
 
    inline bool get_gpio(const std::string& pin) {
        return get_gpio(pin, {});
    }
 
    virtual bool get_gpio(const std::string& pin, const ProtoStruct& extra) = 0;
 
    inline void set_gpio(const std::string& pin, bool high) {
        return set_gpio(pin, high, {});
    }
 
    virtual void set_gpio(const std::string& pin, bool high, const ProtoStruct& extra) = 0;
 
    inline double get_pwm_duty_cycle(const std::string& pin) {
        return get_pwm_duty_cycle(pin, {});
    }
 
    virtual double get_pwm_duty_cycle(const std::string& pin, const ProtoStruct& extra) = 0;
 
    inline void set_pwm_duty_cycle(const std::string& pin, double duty_cycle_pct) {
        return set_pwm_duty_cycle(pin, duty_cycle_pct, {});
    }
 
    virtual void set_pwm_duty_cycle(const std::string& pin,
                                    double duty_cycle_pct,
                                    const ProtoStruct& extra) = 0;
 
    inline uint64_t get_pwm_frequency(const std::string& pin) {
        return get_pwm_frequency(pin, {});
    }
 
    virtual uint64_t get_pwm_frequency(const std::string& pin, const ProtoStruct& extra) = 0;
 
    inline void set_pwm_frequency(const std::string& pin, uint64_t frequency_hz) {
        return set_pwm_frequency(pin, frequency_hz, {});
    }
 
    virtual void set_pwm_frequency(const std::string& pin,
                                   uint64_t frequency_hz,
                                   const ProtoStruct& extra) = 0;
 
    inline analog_response read_analog(const std::string& analog_reader_name) {
        return read_analog(analog_reader_name, {});
    }
 
    virtual analog_response read_analog(const std::string& analog_reader_name,
                                        const ProtoStruct& extra) = 0;
 
    inline void write_analog(const std::string& pin, int value) {
        return write_analog(pin, value, {});
    }
 
    virtual void write_analog(const std::string& pin, int value, const ProtoStruct& extra) = 0;
 
    inline digital_value read_digital_interrupt(const std::string& digital_interrupt_name) {
        return read_digital_interrupt(digital_interrupt_name, {});
    }
 
    virtual digital_value read_digital_interrupt(const std::string& digital_interrupt_name,
                                                 const ProtoStruct& extra) = 0;
 
    inline void stream_ticks(std::vector<std::string> const& digital_interrupt_names,
                             std::function<bool(Tick&& tick)> const& tick_handler) {
        return stream_ticks(digital_interrupt_names, tick_handler, {});
    }
 
    virtual void stream_ticks(std::vector<std::string> const& digital_interrupt_names,
                              std::function<bool(Tick&& tick)> const& tick_handler,
                              const ProtoStruct& extra) = 0;
 
    inline void set_power_mode(power_mode power_mode,
                               const boost::optional<std::chrono::microseconds>& duration = {}) {
        return set_power_mode(power_mode, {}, duration);
    }
 
    virtual void set_power_mode(
        power_mode power_mode,
        const ProtoStruct& extra,
        const boost::optional<std::chrono::microseconds>& duration = {}) = 0;
 
    virtual ProtoStruct do_command(const ProtoStruct& command) = 0;
 
    inline std::vector<GeometryConfig> get_geometries() {
        return get_geometries({});
    }
 
    virtual std::vector<GeometryConfig> get_geometries(const ProtoStruct& extra) = 0;
 
   protected:
    explicit Board(std::string name);
};
 
template <>
struct API::traits<Board> {
    static API api();
};
 
bool operator==(const Board::status& lhs, const Board::status& rhs);
 
}  // namespace sdk
}  // namespace viam