encoder.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
 
#include <viam/sdk/common/proto_value.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/config/resource.hpp>
 
namespace viam {
namespace sdk {
 
class Encoder : public Component {
   public:
    enum class position_type : uint8_t {
        // Unspecified position type
        unspecified = 0,
        // Provided by incremental encoders
        ticks_count = 1,
        // Provided by absolute encoders
        angle_degrees = 2
    };
 
    struct position {
        float value;
        position_type type;
    };
 
    struct properties {
        bool ticks_count_supported;
        bool angle_degrees_supported;
    };
 
    inline position get_position(position_type position_type = position_type::unspecified) {
        return get_position({}, position_type);
    }
 
    virtual position get_position(const ProtoStruct& extra,
                                  position_type position_type = position_type::unspecified) = 0;
 
    inline void reset_position() {
        return reset_position({});
    }
 
    virtual void reset_position(const ProtoStruct& extra) = 0;
 
    inline properties get_properties() {
        return get_properties({});
    }
 
    virtual properties get_properties(const ProtoStruct& extra) = 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;
 
    API api() const override;
 
   protected:
    explicit Encoder(std::string name);
};
 
template <>
struct API::traits<Encoder> {
    static API api();
};
 
bool operator==(const Encoder::position& lhs, const Encoder::position& rhs);
bool operator==(const Encoder::properties& lhs, const Encoder::properties& rhs);
 
}  // namespace sdk
}  // namespace viam