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::rdk {
 
class Robot
{
public:
    Robot(const std::string& robot_sn, bool verbose = true, bool lite = false);
    virtual ~Robot();
 
    //========================================= ACCESSORS ==========================================
    bool lite() const;
 
    bool connected() const;
 
    RobotInfo info() const;
 
    Mode mode() const;
 
    std::map<JointGroup, RobotStates> states() const;
 
    std::map<JointGroup, RobotActions> actions() const;
 
    std::map<JointGroup, bool> stopped() const;
 
    bool all_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_device_on() const;
 
    bool reached_timeliness_failure_limit() const;
 
    std::vector<RobotEvent> event_log() const;
 
    //======================================= SYSTEM CONTROL =======================================
    void ServoOn();
 
    void Home(const std::vector<JointGroup>& groups = {});
 
    void Brake(bool engage);
 
    void SwitchMode(Mode mode);
 
    void Stop();
 
    bool ClearFault(unsigned int timeout_sec = 30);
 
    void SetGlobalVariables(const std::map<std::string, FlexivDataTypes>& global_vars);
 
    std::map<std::string, FlexivDataTypes> global_variables() const;
 
    void SetTimelinessFailureLimit(double percentage = 2.0);
 
    //======================================= 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);
 
    void StopPlan();
 
    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::map<JointGroup, PrimitiveArgs>& primitive_args, bool block_until_started = true);
 
    std::map<JointGroup, PrimitiveStates> primitive_states() const;
 
    //==================================== DIRECT JOINT CONTROL ====================================
    void StreamJointTorque(const std::map<JointGroup, RtJointTorqueCmd>& cmds);
 
    void StreamJointPosition(const std::map<JointGroup, RtJointPositionCmd>& cmds);
 
    void SendJointPosition(const std::map<JointGroup, NrtJointPositionCmd>& cmds);
 
    void SetJointImpedance(
        JointGroup group, const std::vector<double>& K_q, const std::vector<double>& Z_q = {});
 
    void SetMaxContactTorque(JointGroup group, const std::vector<double>& max_torques);
 
    void SetJointInertiaScale(JointGroup group, const std::vector<double>& inertia_scales);
 
    //================================== DIRECT CARTESIAN CONTROL ==================================
    void StreamCartesianMotionForce(const std::map<JointGroup, RtCartesianCmd>& cmds);
 
    void SendCartesianMotionForce(const std::map<JointGroup, NrtCartesianCmd>& cmds);
 
    void SendCartesianMotionForceMultiWaypoint(
        const std::map<JointGroup, NrtCartesianMultiWaypointCmd>& cmds);
 
    void SetCartesianImpedance(JointGroup group, 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(JointGroup group, const std::array<double, kCartDoF>& max_wrench);
 
    void SetNullSpacePosture(JointGroup group, const std::vector<double>& ref_positions);
 
    void SetNullSpaceObjectives(JointGroup group, double linear_manipulability = 0.0,
        double angular_manipulability = 0.0, double ref_positions_tracking = 0.5);
 
    void SetForceControlAxis(JointGroup group, const std::array<bool, kCartDoF>& enabled_axes,
        const std::array<double, kCartDoF / 2>& max_linear_vel = {1.0, 1.0, 1.0});
 
    void SetForceControlFrame(JointGroup group, 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(JointGroup group, bool is_enabled);
 
    //======================================== IO CONTROL ========================================
    void SetDigitalOutputs(const std::map<unsigned int, bool>& digital_outputs);
 
    std::array<bool, kIOPorts> digital_inputs() const;
 
    std::array<bool, kIOPorts> digital_outputs() 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 flexiv::rdk */
 
#endif /* FLEXIV_RDK_ROBOT_HPP_ */