data.hpp

Go to the documentation of this file.

 
#ifndef FLEXIV_RDK_DATA_HPP_
#define FLEXIV_RDK_DATA_HPP_
 
#include <array>
#include <vector>
#include <string>
#include <ostream>
#include <variant>
#include <chrono>
 
namespace flexiv {
namespace rdk {
constexpr size_t kCartDoF = 6;
 
constexpr size_t kSerialJointDoF = 7;
 
constexpr size_t kPoseSize = 7;
 
constexpr size_t kIOPorts = 18;
 
constexpr size_t kMaxExtAxes = 6;
 
enum class OperationalStatus
{
    UNKNOWN = 0,        
    READY,              
    BOOTING,            
    ESTOP_NOT_RELEASED, 
    NOT_ENABLED,        
    RELEASING_BRAKE,    
    MINOR_FAULT,        
    CRITICAL_FAULT,     
    IN_REDUCED_STATE,   
    IN_RECOVERY_STATE,  
    IN_MANUAL_MODE,     
    IN_AUTO_MODE,       
};
 
static const std::array<std::string, static_cast<size_t>(OperationalStatus::IN_AUTO_MODE) + 1>
    kOpStatusNames = {"Unknown status", "Ready", "System booting", "E-Stop not released",
        "Not enabled", "Releasing brakes", "Minor fault occurred", "Critical fault occurred",
        "In reduced state", "In recovery state", "In Manual mode", "In regular Auto mode"};
 
enum class CoordType
{
    WORLD, 
    TCP,   
};
 
struct RobotEvent
{
    enum Level
    {
        UNKNOWN = 0,
        INFO,
        WARNING,
        ERROR,
        CRITICAL,
    };
 
    Level level = UNKNOWN;
 
    int id = 0;
 
    std::string description = "";
 
    std::string consequences = "";
 
    std::string probable_causes = "";
 
    std::string recommended_actions = "";
 
    std::chrono::time_point<std::chrono::system_clock> timestamp;
};
 
struct RobotInfo
{
    std::string serial_num = {};
 
    std::string software_ver = {};
 
    std::string model_name = {};
 
    std::string license_type = {};
 
    size_t DoF_e = {};
 
    size_t DoF_m = {};
 
    size_t DoF = {};
 
    std::array<double, kCartDoF> K_x_nom = {};
 
    std::vector<double> K_q_nom = {};
 
    std::vector<double> q_min = {};
 
    std::vector<double> q_max = {};
 
    std::vector<double> dq_max = {};
 
    std::vector<double> tau_max = {};
 
    bool has_FT_sensor = false;
};
 
struct RobotStates
{
    std::pair<int, int> timestamp = {};
 
    std::vector<double> q = {};
 
    std::vector<double> theta = {};
 
    std::vector<double> dq = {};
 
    std::vector<double> dtheta = {};
 
    std::vector<double> tau = {};
 
    std::vector<double> tau_des = {};
 
    std::vector<double> tau_dot = {};
 
    std::vector<double> tau_ext = {};
 
    std::vector<double> tau_interact = {};
 
    std::vector<double> temperature = {};
 
    std::array<double, kPoseSize> tcp_pose = {};
 
    std::array<double, kCartDoF> tcp_vel = {};
 
    std::array<double, kPoseSize> flange_pose = {};
 
    std::array<double, kCartDoF> ft_sensor_raw = {};
 
    std::array<double, kCartDoF> ext_wrench_in_tcp = {};
 
    std::array<double, kCartDoF> ext_wrench_in_world = {};
 
    std::array<double, kCartDoF> ext_wrench_in_tcp_raw = {};
 
    std::array<double, kCartDoF> ext_wrench_in_world_raw = {};
};
 
struct PlanInfo
{
    std::string pt_name = {};
 
    std::string node_name = {};
 
    std::string node_path = {};
 
    std::string node_path_time_period = {};
 
    std::string node_path_number = {};
 
    std::string assigned_plan_name = {};
 
    double velocity_scale = {};
 
    bool waiting_for_step = {};
};
 
struct JPos
{
    JPos(const std::array<double, kSerialJointDoF>& _q_m,
        const std::array<double, kMaxExtAxes>& _q_e = {})
    : q_m(_q_m)
    , q_e(_q_e)
    {
    }
    JPos() = default;
 
    std::array<double, kSerialJointDoF> q_m = {};
 
    std::array<double, kMaxExtAxes> q_e = {};
 
    std::string str() const;
};
 
struct Coord
{
    Coord(const std::array<double, kCartDoF / 2>& _position,
        const std::array<double, kCartDoF / 2>& _orientation,
        const std::array<std::string, 2>& _ref_frame,
        const std::array<double, kSerialJointDoF>& _ref_q_m = {},
        const std::array<double, kMaxExtAxes>& _ref_q_e = {})
    : position(_position)
    , orientation(_orientation)
    , ref_frame(_ref_frame)
    , ref_q_m(_ref_q_m)
    , ref_q_e(_ref_q_e)
    {
    }
    Coord() = default;
 
    std::array<double, kCartDoF / 2> position = {};
 
    std::array<double, kCartDoF / 2> orientation = {};
 
    std::array<std::string, 2> ref_frame = {};
 
    std::array<double, kSerialJointDoF> ref_q_m = {};
 
    std::array<double, kMaxExtAxes> ref_q_e = {};
 
    std::string str() const;
};
 
using FlexivDataTypes = std::variant<int, double, std::string, rdk::JPos, rdk::Coord,
    std::vector<int>, std::vector<double>, std::vector<std::string>, std::vector<rdk::JPos>,
    std::vector<rdk::Coord>>;
 
std::ostream& operator<<(std::ostream& ostream, const RobotEvent& robot_event);
 
std::ostream& operator<<(std::ostream& ostream, const RobotInfo& robot_info);
 
std::ostream& operator<<(std::ostream& ostream, const RobotStates& robot_states);
 
std::ostream& operator<<(std::ostream& ostream, const PlanInfo& plan_info);
 
} /* namespace rdk */
} /* namespace flexiv */
 
#endif /* FLEXIV_RDK_DATA_HPP_ */