Robot.hpp

Go to the documentation of this file.

 
#ifndef FLEXIVRDK_ROBOT_HPP_
#define FLEXIVRDK_ROBOT_HPP_
 
#include "Data.hpp"
#include "Mode.hpp"
 
#include <array>
#include <vector>
#include <memory>
#include <functional>
 
namespace flexiv {
 
class Robot
{
public:
    Robot(const std::string& serverIP, const std::string& localIP);
    virtual ~Robot();
 
    const RobotInfo info(void);
 
    //============================= SYSTEM CONTROL =============================
    void enable(void);
 
    void stop(void);
 
    bool isOperational(bool verbose = true) const;
 
    bool isBusy(void) const;
 
    bool isConnected(void) const;
 
    bool isFault(void) const;
 
    bool isEstopReleased(void) const;
 
    bool isEnablingButtonPressed(void) const;
 
    bool isRecoveryState(void) const;
 
    void connect(void);
 
    void disconnect(void);
 
    void clearFault(void);
 
    void setMode(Mode mode);
 
    Mode getMode(void) const;
 
    //============================ ROBOT OPERATIONS ============================
    void getRobotStates(RobotStates& output);
 
    void executePlan(unsigned int index, bool continueExec = false);
 
    void executePlan(const std::string& name, bool continueExec = false);
 
    void pausePlan(bool pause);
 
    std::vector<std::string> getPlanNameList(void) const;
 
    void getPlanInfo(PlanInfo& output);
 
    void executePrimitive(const std::string& ptCmd);
 
    std::vector<std::string> getPrimitiveStates(void) const;
 
    void setGlobalVariables(const std::string& globalVars);
 
    std::vector<std::string> getGlobalVariables(void) const;
 
    bool isStopped(void) const;
 
    void switchTcp(unsigned int index);
 
    void runAutoRecovery(void);
 
    //========================== DIRECT JOINT CONTROL ==========================
    void streamJointTorque(const std::vector<double>& torques,
        bool enableGravityComp = true, bool enableSoftLimits = 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>& maxVel, const std::vector<double>& maxAcc);
 
    //======================== DIRECT CARTESIAN CONTROL ========================
    void streamCartesianMotionForce(const std::vector<double>& pose,
        const std::vector<double>& wrench = std::vector<double>(6));
 
    void sendCartesianMotionForce(const std::vector<double>& pose,
        const std::vector<double>& wrench = std::vector<double>(6),
        double maxLinearVel = 0.5, double maxAngularVel = 1.0);
 
    void setCartesianStiffness(const std::vector<double>& stiffness);
 
    void resetCartesianStiffness(void);
 
    void setMaxContactWrench(const std::vector<double>& maxWrench);
 
    void resetMaxContactWrench(void);
 
    void setNullSpacePosture(const std::vector<double>& preferredPositions);
 
    void resetNullSpacePosture(void);
 
    void setForceControlAxis(const std::vector<bool>& enabledAxis);
 
    void setForceControlFrame(const std::string& referenceFrame);
 
    void setPassiveForceControl(bool isEnabled);
 
    //=============================== IO CONTROL ===============================
    void writeDigitalOutput(const std::vector<unsigned int>& portIdx,
        const std::vector<bool>& values);
 
    std::array<bool, k_IOPorts> readDigitalInput(void);
 
private:
    class Impl;
    std::unique_ptr<Impl> m_pimpl;
 
    friend class Model;
    friend class Gripper;
};
 
} /* namespace flexiv */
 
#endif /* FLEXIVRDK_ROBOT_HPP_ */