arm.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
 
#include <boost/optional/optional.hpp>
#include <boost/variant/variant.hpp>
 
#include <viam/sdk/common/kinematics.hpp>
#include <viam/sdk/common/mesh.hpp>
#include <viam/sdk/common/pose.hpp>
#include <viam/sdk/resource/stoppable.hpp>
#include <viam/sdk/spatialmath/geometry.hpp>
 
namespace viam {
namespace sdk {
 
 
class Arm : public Component, public Stoppable {
   public:
    using KinematicsDataUnspecified
        [[deprecated("Use ::viam::sdk::KinematicsDataUnspecified instead")]] =
            ::viam::sdk::KinematicsDataUnspecified;
    using KinematicsDataSVA [[deprecated("Use ::viam::sdk::KinematicsDataSVA instead")]] =
        ::viam::sdk::KinematicsDataSVA;
    using KinematicsDataURDF [[deprecated("Use ::viam::sdk::KinematicsDataURDF instead")]] =
        ::viam::sdk::KinematicsDataURDF;
    using KinematicsData [[deprecated("Use ::viam::sdk::KinematicsData instead")]] =
        ::viam::sdk::KinematicsData;
 
    using MoveLimit = boost::variant<double, std::vector<double>>;
 
    struct MoveOptions {
        boost::optional<MoveLimit> max_vel_degs_per_sec;
        boost::optional<MoveLimit> max_acc_degs_per_sec2;
    };
 
    inline pose get_end_position() {
        return get_end_position({});
    }
 
    virtual pose get_end_position(const ProtoStruct& extra) = 0;
 
    inline void move_to_position(const pose& pose) {
        move_to_position(pose, {});
    }
 
    virtual void move_to_position(const pose& pose, const ProtoStruct& extra) = 0;
 
    inline std::vector<double> get_joint_positions() {
        return get_joint_positions({});
    }
 
    virtual std::vector<double> get_joint_positions(const ProtoStruct& extra) = 0;
 
    inline void move_to_joint_positions(const std::vector<double>& positions) {
        return move_to_joint_positions(positions, {});
    }
 
    virtual void move_to_joint_positions(const std::vector<double>& positions,
                                         const ProtoStruct& extra) = 0;
 
    inline void move_through_joint_positions(const std::vector<std::vector<double>>& positions,
                                             const MoveOptions& options) {
        return move_through_joint_positions(positions, options, {});
    }
 
    virtual void move_through_joint_positions(const std::vector<std::vector<double>>& positions,
                                              const MoveOptions& options,
                                              const ProtoStruct& extra) = 0;
 
    virtual bool is_moving() = 0;
 
    virtual ProtoStruct do_command(const ProtoStruct& command) = 0;
 
    virtual ::viam::sdk::KinematicsData get_kinematics(const ProtoStruct& extra) = 0;
 
    inline ::viam::sdk::KinematicsData get_kinematics() {
        return get_kinematics({});
    }
 
    virtual std::map<std::string, mesh> get_3d_models(const ProtoStruct& extra) = 0;
 
    inline std::map<std::string, mesh> get_3d_models() {
        return get_3d_models({});
    }
 
    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 Arm(std::string name);
};
 
template <>
struct API::traits<Arm> {
    static API api();
};
 
}  // namespace sdk
}  // namespace viam