data_types_cli.hpp

浏览该文件的文档.

 
#pragma once
#ifndef XCORESDK_SRC_CLI_DATA_TYPES_CLI_HPP_
#define XCORESDK_SRC_CLI_DATA_TYPES_CLI_HPP_
 
#include <unordered_map>
#include <any>
#include <string>
 
using namespace System;
using namespace System::Collections::Generic;
 
namespace rokae::clr {
 
    public ref class ErrorCode {
    private:
        int value_;
        String^ message_;
    public:
        
        ErrorCode(int v, String^ m) : value_(v), message_(m) {};
        property String^ message {
            String^ get() {
                return message_;
            }
        }
        property int value {
            int get() {
                return value_;
            }
        }
    };
 
    public enum class PowerState {
        on = 0,
        off = 1,
        estop = 2,
        gstop = 3,
        unknown = -1
    };
 
    public enum class OperateMode {
        manual = 0,
        automatic = 1,
        unknown = -1
    };
 
    public enum class OperationState {
        idle = 0,
        jog = 1,
        rtControlling = 2,
        drag = 3,
        rlProgram = 4,
        demo = 5,
        dynamicIdentify = 6,
        frictionIdentify = 7,
        loadIdentify = 8,
        moving = 9,
        jogging = 10,
        unknown = -1
    };
 
    public enum class WorkType {
        industrial = 0,
        collaborative = 1
    };
 
    public enum class CoordinateType {
        flangeInBase,
        endInRef 
    };
 
    public enum class StopLevel {
        stop0,
        stop1,
        stop2,
        suppleStop
    };
 
    public enum class MotionControlMode {
        Idle,
        NrtCommand,
        NrtRLTask,
        RtCommand,
    };
 
    public enum class RtControllerMode {
        jointPosition = 0,
        cartesianPosition = 1,
        jointImpedance = 2,
        cartesianImpedance = 3,
        torque = 4
    };
 
    public enum class SegmentFrame {
        joint1 = 1,
        joint2 = 2,
        joint3 = 3,
        joint4 = 4,
        joint5 = 5,
        joint6 = 6,
        joint7 = 7,
        flange = 8,
        endEffector = 9,
        stiffness = 10
    };
 
    public enum class JogSpace {
        world = 0,
        flange,
        baseFrame,
        toolFrame,
        wobjFrame,
        jointSpace,
        singularityAvoidMode,
        baseParallelMode
    };
 
    public value struct JogOpt {
        enum class Space {
            world = 0,
            flange,
            baseFrame,
            toolFrame,
            wobjFrame,
            jointSpace,
            singularityAvoidMode,
            baseParallelMode
        };
    };
 
    public enum class FrameType {
        world = 0,
        baseFrame = 1,
        flange = 2,
        tool = 3,
        wobj = 4,
        path = 5,
        rail = 6
    };
 
    public value struct DragOpt {
    public:
        enum class Space {
            jointSpace = 0,
            cartesianSpace = 1 
        };
        enum class Type {
            translationOnly = 0,
            rotationOnly = 1,
            freely = 2
        };
    };
 
    public value struct DragParameter {
    public:
        enum class Space {
            jointSpace = 0,
            cartesianSpace = 1
        };
        enum class Type {
            translationOnly = 0,
            rotationOnly = 1,
            freely = 2
        };
    };
 
    public value struct xPanelOpt {
        enum class Vout {
            off,
            reserve,
            supply12v,
            supply24v
        };
    };
 
    public enum class AvoidSingularityMethod {
        lockAxis4,
        wrist,
        jointWay
    };
 
    typedef System::Collections::Generic::Dictionary<String^, System::Object^>^ EventInfo;
    public delegate void EventCallbackDelegate(EventInfo);
    public delegate void EventCallbackNativeDelegate(const std::unordered_map<std::string, std::any>&);
    typedef void(__stdcall * EventCallbackPtr)(const std::unordered_map<std::string, std::any> &);
 
    public delegate void ConnectionHandlerDelegate(bool);
    typedef void(__stdcall* ConnectionHandlerPtr)(bool);
 
    public enum class Event {
        moveExecution,
        safety,
        rlExecution,
        logReporter
    };
 
    public value struct Info {
        String^ id;
        String^ mac;
        String^ version;
        String^ type;
        Int32 joint_num;
    };
 
    public ref class Frame {
    public:
        Frame(array<double>^ _trans, array<double>^ _rpy) : trans(_trans), rpy(_rpy) {}
        
        Frame(array<double>^ _frame) : trans(gcnew array<double>(3)), rpy(gcnew array<double>(3)) {
            if (_frame->Length < 6) {
                throw gcnew System::IndexOutOfRangeException();
            }
            trans[0] = _frame[0];
            trans[1] = _frame[1];
            trans[2] = _frame[2];
            rpy[0] = _frame[3];
            rpy[1] = _frame[4];
            rpy[2] = _frame[5];
        }
 
        Frame(): trans(gcnew array<double>(3)), rpy(gcnew array<double>(3)){}
        array<double>^ trans;
        array<double>^ rpy;
    };
 
    public ref class CartesianPosition : public Frame {
    public:
        ref class Offset {
        public:
            enum class Type {
                none,
                offs,
                relTool
            };
            Offset(): type(Type::none), frame(gcnew Frame()) {};
            Type type;    
            Frame^ frame;
        };
        CartesianPosition(): Frame(), elbow(0), confData(gcnew List<int>), external(gcnew List<double>) {};
        
        double elbow;
        List<int>^ confData;
        List<double>^ external; 
    };
  
    public ref class JointPosition {
    public:
        JointPosition() : joints(gcnew List<double>()), external(gcnew List<double>()) {};
        List<double>^ joints;
        List<double>^ external;
    };
  
    public ref class MoveCommand {
    public:
        enum class Type {
            MoveL, 
            MoveJ,
            MoveAbsJ,
            MoveC,
            MoveCF,
            MoveSP,
            MoveWait
 
        };
 
        CartesianPosition^ cartTarget;
        JointPosition^ jointTarget;
        CartesianPosition^ auxPoint;
        CartesianPosition::Offset^ cartTargetOffset;
        CartesianPosition::Offset^ auxPointOffset;
        double speed;
        double jointSpeed;
        double rotSpeed;
        double zone;
        String^ customInfo;
 
        List<double>^ args;
 
        MoveCommand() : cartTarget(gcnew CartesianPosition()),
            jointTarget(gcnew JointPosition()),
            auxPoint(gcnew CartesianPosition()),
            cartTargetOffset(gcnew CartesianPosition::Offset()),
            auxPointOffset(gcnew CartesianPosition::Offset()),
            speed(-1), jointSpeed(-1), rotSpeed(-1), zone(-1), customInfo(gcnew String("")), args(gcnew List<double>()) {};
    };
 
    public ref class Load {
    public:
        Load(): mass(0.0), cog(gcnew array<double>(3)), inertia(gcnew array<double>(3)){}
        Load(double m, array<double>^ c, array<double>^ i): mass(m), cog(c), inertia(i) {}
        double mass;
        array<double>^ cog;
        array<double>^ inertia;
    };
 
    public value struct StateList {
        array<double>^ joint_pos;
 
        CartesianPosition^ cart_pos;
 
        array<System::Tuple<String^, Boolean>^>^ digital_signals;
        array<System::Tuple<String^, Double>^>^ analog_signals;
        OperateMode operation_mode;
        double speed_override;
    };
 
 
    public ref class Toolset {
    public:
        Toolset() : load(gcnew Load()), end(gcnew Frame()), reference(gcnew Frame()) {}
        Load^ load;
        Frame^ end;
        Frame^ reference;
    };
 
    public ref class FrameCalibrationResult {
     public:
         FrameCalibrationResult() : frame(gcnew Frame()), errors(gcnew array<double>(3)) {}
         FrameCalibrationResult(Frame^ f, array<double>^ e): frame(f), errors(e){}
         Frame^ frame;
         array<double>^ errors{};
    };
 
    public enum class LogInfoLevel {
        info,
        warning,
        err
    };
 
    public ref class LogInfo {
    public:
        LogInfo(int _id, String^ ts, String^ ct, String^ r): id(_id),
            timestamp(ts), logText(ct), repairHint(r) {}
        initonly int id;
        String^ timestamp;
        String^ logText;
        String^ repairHint;
    };
 
    public value struct KeyPadState {
        bool key1_state;
        bool key2_state;
        bool key3_state;
        bool key4_state;
        bool key5_state;
        bool key6_state;
        bool key7_state;
    };
 
    public value struct SlaveInfo {
        UInt32 vendorId;
        UInt32 productCode;
        UInt32 reversionNumber;
        UInt16 slaveAddr;
        UInt32 slaveId;
        UInt16 alStatus;
        String^ slaveName;
    };
 
    public ref class SDOData {
    public:
        int index;
        int sub_index;
        int length;
        int over_time;
        int wait_time;
        int print_data;
        array<Byte>^ data;
        SDOData()
            : index(0),
              sub_index(0),
              length(0),
              over_time(0),
              wait_time(0),
              print_data(0),
              data(gcnew array<Byte>(50)) {}
    };
 
    public enum class CANFormat {
        STANDARD = 0, 
        EXTENDED = 1  
    };
 
    public enum class CANType {
        CANFD_ACCELERATED = 0, 
        CANFD = 1,             
        CanClassic = 2         
    };
 
    public enum class BackupItem {
        customConfig = 0,
        robotConfig = 1,
        robotConfigWithoutBodyParams = 2,
        controllerLog = 3,
        systemLog = 4,
        rlProgram = 5,
        backupRlProgram = 6,
        sdkRecordPath = 7
    };
 
    public ref class CANFrame {
    public:
        CANFrame()
            : frame_id(0),
              frame_format((int)CANFormat::STANDARD),
              frame_type(2),
              data(gcnew array<Byte>(0)),
              frame_valid_length(0) {}
 
        CANFrame(int id, int format, int type, array<Byte>^ bytes, int valid_len)
            : frame_id(id),
              frame_format(format),
              frame_type(type),
              data(bytes == nullptr ? gcnew array<Byte>(0) : bytes),
              frame_valid_length(valid_len) {}
 
        int frame_id;           
        int frame_format;       
        int frame_type;         
        array<Byte>^ data;      
        int frame_valid_length; 
    };
 
    public ref class RLProjectInfo {
    public:
        RLProjectInfo(String^ n): name(n), taskList(gcnew List<String^>()){}
        String^ name;
        List<String^>^ taskList;
    };
 
    public ref class WorkToolInfo {
    public:
        WorkToolInfo(): name(gcnew String("")), alias(gcnew String("")),
            robotHeld(false), pos(gcnew Frame()), load(gcnew Load()) {}
        WorkToolInfo(String^ n, String^ a, bool isHeld, Frame^ p, Load^ l):
            name(n), alias(a), robotHeld(isHeld), pos(p), load(l) {}
        
        String^ name;
        String^ alias;
        bool robotHeld;
        Frame^ pos;
        Load^ load;
    };
 
}
#endif // XCORESDK_SRC_CLI_DATA_TYPES_CLI_HPP_