base.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
 
#include <viam/api/component/base/v1/base.pb.h>
 
#include <viam/sdk/common/linear_algebra.hpp>
#include <viam/sdk/common/proto_type.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/config/resource.hpp>
#include <viam/sdk/resource/stoppable.hpp>
 
namespace viam {
namespace sdk {
 
 
class Base : public Component, public Stoppable {
   public:
    struct properties {
        double width_meters;
        double turning_radius_meters;
        double wheel_circumference_meters;
 
        static properties from_proto(const component::base::v1::GetPropertiesResponse& proto);
    };
    friend std::ostream& operator<<(std::ostream& os, const properties& v);
    friend bool operator==(const properties& lhs, const properties& rhs);
 
    inline void move_straight(int64_t distance_mm, double mm_per_sec) {
        return move_straight(distance_mm, mm_per_sec, {});
    }
 
    virtual void move_straight(int64_t distance_mm,
                               double mm_per_sec,
                               const AttributeMap& extra) = 0;
 
    inline void spin(double angle_deg, double degs_per_sec) {
        return spin(angle_deg, degs_per_sec, {});
    }
 
    virtual void spin(double angle_deg, double degs_per_sec, const AttributeMap& extra) = 0;
 
    inline void set_power(const Vector3& linear, const Vector3& angular) {
        return set_power(linear, angular, {});
    }
 
    virtual void set_power(const Vector3& linear,
                           const Vector3& angular,
                           const AttributeMap& extra) = 0;
 
    inline void set_velocity(const Vector3& linear, const Vector3& angular) {
        return set_velocity(linear, angular, {});
    }
 
    virtual void set_velocity(const Vector3& linear,
                              const Vector3& angular,
                              const AttributeMap& extra) = 0;
 
    virtual bool is_moving() = 0;
 
    inline properties get_properties() {
        return get_properties({});
    }
 
    virtual properties get_properties(const AttributeMap& extra) = 0;
 
    virtual AttributeMap do_command(const AttributeMap& command) = 0;
 
    inline std::vector<GeometryConfig> get_geometries() {
        return get_geometries({});
    }
 
    virtual std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) = 0;
 
    API api() const override;
 
   protected:
    explicit Base(std::string name);
};
 
template <>
struct API::traits<Base> {
    static API api();
};
 
}  // namespace sdk
}  // namespace viam