arm.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <functional>
#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/common/proto_convert.hpp>
#include <viam/sdk/resource/stoppable.hpp>
#include <viam/sdk/spatialmath/geometry.hpp>
 
namespace viam {
namespace component {
namespace arm {
namespace v1 {
 
class TrajectoryPoint;
class MoveThroughJointPositionsStreamedResponse;
class GetPropertiesResponse;
 
}  // namespace v1
}  // namespace arm
}  // namespace component
}  // namespace viam
 
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;
        boost::optional<double> max_tcp_speed;
    };
 
    struct properties {
        bool support_manual_mode = false;
        bool support_cartesian_commands = false;
    };
 
    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;
 
    struct trajectory_point {
        struct kinematic_constraints {
            std::vector<double> velocities_degs_per_sec;
            boost::optional<std::vector<double>> accelerations_degs_per_sec2;
        };
 
        std::chrono::microseconds time;
 
        std::vector<double> positions;
 
        boost::optional<kinematic_constraints> constraints;
    };
 
    struct trajectory_update {};
 
    enum class stream_outcome : std::uint8_t {
        k_completed = 0,  
        k_halted_by_update_handler =
            1,  
    };
 
    inline stream_outcome move_through_joint_positions_streamed(
        const std::function<boost::optional<std::vector<trajectory_point>>()>& batch_source,
        const std::function<bool(trajectory_update)>& update_handler) {
        return move_through_joint_positions_streamed(batch_source, update_handler, {});
    }
 
    virtual stream_outcome move_through_joint_positions_streamed(
        const std::function<boost::optional<std::vector<trajectory_point>>()>& batch_source,
        const std::function<bool(trajectory_update)>& update_handler,
        const ProtoStruct& extra) = 0;
 
    virtual bool is_moving() = 0;
 
    virtual ProtoStruct get_status() = 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;
 
    inline properties get_properties() {
        return get_properties({});
    }
 
    virtual properties get_properties(const ProtoStruct& extra) = 0;
 
    inline void set_manual_mode(bool manual_mode) {
        return set_manual_mode(manual_mode, std::chrono::seconds::zero(), {});
    }
 
    inline void set_manual_mode(bool manual_mode, std::chrono::seconds enabled_for) {
        return set_manual_mode(manual_mode, enabled_for, {});
    }
 
    virtual void set_manual_mode(bool manual_mode,
                                 std::chrono::seconds enabled_for,
                                 const ProtoStruct& extra) = 0;
 
    inline bool get_manual_mode() {
        return get_manual_mode({});
    }
 
    virtual bool get_manual_mode(const ProtoStruct& extra) = 0;
 
    API api() const override;
 
   protected:
    explicit Arm(std::string name);
};
 
template <>
struct API::traits<Arm> {
    static API api();
};
 
bool operator==(const Arm::properties& lhs, const Arm::properties& rhs);
 
namespace proto_convert_details {
 
template <>
struct to_proto_impl<Arm::trajectory_point> {
    void operator()(const Arm::trajectory_point&, viam::component::arm::v1::TrajectoryPoint*) const;
};
 
template <>
struct from_proto_impl<viam::component::arm::v1::TrajectoryPoint> {
    Arm::trajectory_point operator()(const viam::component::arm::v1::TrajectoryPoint*) const;
};
 
template <>
struct to_proto_impl<Arm::trajectory_update> {
    void operator()(const Arm::trajectory_update&,
                    viam::component::arm::v1::MoveThroughJointPositionsStreamedResponse*) const;
};
 
template <>
struct from_proto_impl<viam::component::arm::v1::MoveThroughJointPositionsStreamedResponse> {
    Arm::trajectory_update operator()(
        const viam::component::arm::v1::MoveThroughJointPositionsStreamedResponse*) const;
};
 
template <>
struct to_proto_impl<Arm::properties> {
    void operator()(const Arm::properties&, viam::component::arm::v1::GetPropertiesResponse*) const;
};
 
template <>
struct from_proto_impl<viam::component::arm::v1::GetPropertiesResponse> {
    Arm::properties operator()(const viam::component::arm::v1::GetPropertiesResponse*) const;
};
 
}  // namespace proto_convert_details
 
}  // namespace sdk
}  // namespace viam