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>
#include <map>
 
namespace flexiv {
namespace rdk {
 
class Robot
{
public:
    Robot(const std::string& robot_sn,
        const std::vector<std::string>& network_interface_whitelist = {}, bool verbose = true);
    virtual ~Robot();
 
    //========================================= ACCESSORS ==========================================
    bool connected() const;
 
    RobotInfo info() const;
 
    Mode mode() const;
 
    RobotStates states() const;
 
    bool stopped() const;
 
    bool operational() const;
 
    OperationalStatus operational_status() const;
 
    bool busy() const;
 
    bool fault() const;
 
    bool reduced() const;
 
    bool recovery() const;
 
    bool estop_released() const;
 
    bool enabling_button_pressed() const;
 
    std::vector<RobotEvent> event_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 SetGlobalVariables(const std::map<std::string, FlexivDataTypes>& global_vars);
 
    std::map<std::string, FlexivDataTypes> global_variables() const;
 
    void LockExternalAxes(bool toggle);
 
    //======================================= PLAN EXECUTION =======================================
    void ExecutePlan(
        unsigned int index, bool continue_exec = false, bool block_until_started = true);
 
    void ExecutePlan(
        const std::string& name, bool continue_exec = false, bool block_until_started = true);
 
    void PausePlan(bool toggle);
 
    std::vector<std::string> plan_list() const;
 
    PlanInfo plan_info() const;
 
    void SetBreakpointMode(bool is_enabled);
 
    void StepBreakpoint();
 
    void SetVelocityScale(unsigned int velocity_scale);
 
    //==================================== PRIMITIVE EXECUTION =====================================
    void ExecutePrimitive(const std::string& primitive_name,
        const std::map<std::string, FlexivDataTypes>& input_params,
        bool block_until_started = true);
 
    std::map<std::string, FlexivDataTypes> 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 = {});
 
    //================================== DIRECT CARTESIAN CONTROL ==================================
    void StreamCartesianMotionForce(const std::array<double, kPoseSize>& pose,
        const std::array<double, kCartDoF>& wrench = {},
        const std::array<double, kCartDoF>& velocity = {},
        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 SetMaxContactWrench(const std::array<double, kCartDoF>& max_wrench);
 
    void SetNullSpacePosture(const std::vector<double>& ref_positions);
 
    void SetNullSpaceObjectives(double linear_manipulability = 0.0,
        double angular_manipulability = 0.0, double ref_positions_tracking = 0.5);
 
    void SetForceControlAxis(const std::array<bool, kCartDoF>& enabled_axes,
        const std::array<double, kCartDoF / 2>& max_linear_vel = {1.0, 1.0, 1.0});
 
    void SetForceControlFrame(CoordType root_coord,
        const std::array<double, kPoseSize>& T_in_root = {0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0});
 
    void SetPassiveForceControl(bool is_enabled);
 
    //======================================== IO CONTROL ========================================
    void SetDigitalOutputs(const std::map<unsigned int, bool>& digital_outputs);
 
    [[deprecated("Use the other SetDigitalOutputs() instead")]] void SetDigitalOutputs(
        const std::vector<unsigned int>& port_idx, const std::vector<bool>& values);
 
    std::array<bool, kIOPorts> digital_inputs() const;
 
private:
    class Impl;
    std::unique_ptr<Impl> pimpl_;
 
    friend class Device;
    friend class FileIO;
    friend class Gripper;
    friend class Maintenance;
    friend class Model;
    friend class Safety;
    friend class Tool;
    friend class WorkCoord;
};
 
} /* namespace rdk */
} /* namespace flexiv */
 
#endif /* FLEXIV_RDK_ROBOT_HPP_ */