robot.hpp

Go to the documentation of this file.

 
#ifndef FLEXIV_RDK_ROBOT_HPP_
#define FLEXIV_RDK_ROBOT_HPP_
 
#include "data.hpp"
#include "mode.hpp"
#include <vector>
#include <memory>
#include <exception>
 
namespace flexiv {
namespace rdk {
 
class Robot
{
public:
    Robot(const std::string& robot_sn);
    virtual ~Robot();
 
    //========================================= ACCESSORS ==========================================
    bool connected() const;
 
    const RobotInfo info() const;
 
    Mode mode() const;
 
    const RobotStates states() const;
 
    bool stopped() const;
 
    bool operational(bool verbose = true) const;
 
    bool busy() const;
 
    bool fault() const;
 
    bool recovery() const;
 
    bool estop_released() const;
 
    bool enabling_button_pressed() const;
 
    const std::vector<std::string> mu_log() const;
 
    //======================================= SYSTEM CONTROL =======================================
    void Enable();
 
    void Brake(bool engage);
 
    void SwitchMode(Mode mode);
 
    void Stop();
 
    bool ClearFault(unsigned int timeout_sec = 30);
 
    void RunAutoRecovery();
 
    void SetVelocityScale(unsigned int velocity_scale);
 
    //======================================= PLAN EXECUTION =======================================
    void ExecutePlan(unsigned int index, bool continue_exec = false);
 
    void ExecutePlan(const std::string& name, bool continue_exec = false);
 
    void PausePlan(bool pause);
 
    const std::vector<std::string> plan_list() const;
 
    const PlanInfo plan_info() const;
 
    void SetGlobalVariables(const std::string& global_vars);
 
    const std::vector<std::string> global_variables() const;
 
    void SetBreakpointMode(bool is_enabled);
 
    void StepBreakpoint();
 
    //==================================== PRIMITIVE EXECUTION =====================================
    void ExecutePrimitive(const std::string& pt_cmd);
 
    const std::vector<std::string> primitive_states() const;
 
    //==================================== DIRECT JOINT CONTROL ====================================
    void StreamJointTorque(const std::vector<double>& torques, bool enable_gravity_comp = true,
        bool enable_soft_limits = true);
 
    void StreamJointPosition(const std::vector<double>& positions,
        const std::vector<double>& velocities, const std::vector<double>& accelerations);
 
    void SendJointPosition(const std::vector<double>& positions,
        const std::vector<double>& velocities, const std::vector<double>& accelerations,
        const std::vector<double>& max_vel, const std::vector<double>& max_acc);
 
    void SetJointImpedance(const std::vector<double>& K_q,
        const std::vector<double>& Z_q = {0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7});
 
    void ResetJointImpedance();
 
    //================================== DIRECT CARTESIAN CONTROL ==================================
    void StreamCartesianMotionForce(const std::array<double, kPoseSize>& pose,
        const std::array<double, kCartDoF>& wrench = {},
        const std::array<double, kCartDoF>& acceleration = {});
 
    void SendCartesianMotionForce(const std::array<double, kPoseSize>& pose,
        const std::array<double, kCartDoF>& wrench = {}, double max_linear_vel = 0.5,
        double max_angular_vel = 1.0, double max_linear_acc = 2.0, double max_angular_acc = 5.0);
 
    void SetCartesianImpedance(const std::array<double, kCartDoF>& K_x,
        const std::array<double, kCartDoF>& Z_x = {0.7, 0.7, 0.7, 0.7, 0.7, 0.7});
 
    void ResetCartesianImpedance();
 
    void SetMaxContactWrench(const std::array<double, kCartDoF>& max_wrench);
 
    void ResetMaxContactWrench();
 
    void SetNullSpacePosture(const std::vector<double>& preferred_positions);
 
    void ResetNullSpacePosture();
 
    void SetForceControlAxis(const std::array<bool, kCartDoF>& enabled_axis,
        const std::array<double, kCartDoF / 2>& max_linear_vel = {1.0, 1.0, 1.0});
 
    void SetForceControlFrame(const std::string& reference_frame);
 
    void SetPassiveForceControl(bool is_enabled);
 
    //======================================== IO CONTROL ========================================
    void WriteDigitalOutput(
        const std::vector<unsigned int>& port_idx, const std::vector<bool>& values);
 
    const std::array<bool, kIOPorts> ReadDigitalInput();
 
private:
    class Impl;
    std::unique_ptr<Impl> pimpl_;
 
    friend class Model;
    friend class Gripper;
    friend class Device;
    friend class Tool;
    friend class FileIO;
};
 
} /* namespace rdk */
} /* namespace flexiv */
 
#endif /* FLEXIV_RDK_ROBOT_HPP_ */