movement_sensor.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
 
#include <viam/sdk/common/linear_algebra.hpp>
#include <viam/sdk/common/proto_value.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/config/resource.hpp>
#include <viam/sdk/spatialmath/orientation.hpp>
 
namespace viam {
namespace sdk {
 
 
class MovementSensor : public Component {
   public:
    struct compassheading {
        double value;
    };
 
    struct orientation {
        double o_x, o_y, o_z, theta;
    };
 
    struct position {
        geo_point coordinate;
        float altitude_m;
    };
 
    struct properties {
        bool linear_velocity_supported;
        bool angular_velocity_supported;
        bool orientation_supported;
        bool position_supported;
        bool compass_heading_supported;
        bool linear_acceleration_supported;
    };
 
    API api() const override;
 
    inline Vector3 get_linear_velocity() {
        return get_linear_velocity({});
    }
 
    virtual Vector3 get_linear_velocity(const ProtoStruct& extra) = 0;
 
    inline Vector3 get_angular_velocity() {
        return get_angular_velocity({});
    }
 
    virtual Vector3 get_angular_velocity(const ProtoStruct& extra) = 0;
 
    inline compassheading get_compass_heading() {
        return get_compass_heading({});
    }
 
    virtual compassheading get_compass_heading(const ProtoStruct& extra) = 0;
 
    inline orientation get_orientation() {
        return get_orientation({});
    }
 
    virtual orientation get_orientation(const ProtoStruct& extra) = 0;
 
    inline position get_position() {
        return get_position({});
    }
 
    virtual position get_position(const ProtoStruct& extra) = 0;
 
    inline properties get_properties() {
        return get_properties({});
    }
 
    virtual properties get_properties(const ProtoStruct& extra) = 0;
 
    inline std::unordered_map<std::string, float> get_accuracy() {
        return get_accuracy({});
    }
 
    virtual std::unordered_map<std::string, float> get_accuracy(const ProtoStruct& extra) = 0;
 
    inline Vector3 get_linear_acceleration() {
        return get_linear_acceleration({});
    }
 
    virtual Vector3 get_linear_acceleration(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;
 
   protected:
    explicit MovementSensor(std::string name) : Component(std::move(name)) {}
};
 
template <>
struct API::traits<MovementSensor> {
    static API api();
};
 
bool operator==(const MovementSensor::compassheading& lhs,
                const MovementSensor::compassheading& rhs);
bool operator==(const MovementSensor::position& lhs, const MovementSensor::position& rhs);
bool operator==(const MovementSensor::properties& lhs, const MovementSensor::properties& rhs);
}  // namespace sdk
}  // namespace viam