arm.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
 
#include <boost/optional/optional.hpp>
#include <boost/variant/variant.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 {
    // Base class for use below in defining kinematics data strong typedefs
    template <class Tag>
    struct raw_bytes {
        // Pre c++17 our derived classes aren't aggregate initializable so we need to define
        // and using declare some ctors
 
        raw_bytes() = default;
        raw_bytes(std::vector<unsigned char> b) : bytes(std::move(b)) {}
 
        std::vector<unsigned char> bytes{};
    };
 
    // Comparison operator helper for the data types below
    template <class DataType>
    struct EqCompare {
        inline friend bool operator==(const DataType& lhs, const DataType& rhs) {
            return lhs.bytes == rhs.bytes;
        }
    };
 
   public:
    struct KinematicsDataUnspecified : raw_bytes<KinematicsDataUnspecified>,
                                       EqCompare<KinematicsDataUnspecified> {};
    struct KinematicsDataSVA : raw_bytes<KinematicsDataSVA>, EqCompare<KinematicsDataSVA> {
        using raw_bytes<KinematicsDataSVA>::raw_bytes;
    };
    struct KinematicsDataURDF : raw_bytes<KinematicsDataURDF>, EqCompare<KinematicsDataURDF> {
        using raw_bytes<KinematicsDataURDF>::raw_bytes;
    };
 
    using KinematicsData =
        boost::variant<KinematicsDataUnspecified, KinematicsDataSVA, KinematicsDataURDF>;
 
    struct MoveOptions {
        boost::optional<double> max_vel_degs_per_sec;
        boost::optional<double> 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 KinematicsData get_kinematics(const ProtoStruct& extra) = 0;
 
    inline 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