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>
 
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 CoordinateType {
        flangeInBase,
        endInRef 
    };
 
    public enum class StopLevel {
        stop0,
        stop1,
        stop2,
        suppleStop
    };
 
    public enum class MotionControlMode {
        Idle,
        NrtCommand,
        NrtRLTask,
        RtCommand,
    };
 
    public enum class JogSpace {
        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 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 ref class LogInfo {
    public:
        enum class Level {
            info,
            warning,
            error
        };
        LogInfo(int _id, String^ ts, String^ ct, String^ r): id(_id),
            timestamp(ts), content(ct), repair(r) {}
        const int id;
        String^ timestamp;
        String^ content; 
        String^ repair;
    };
 
    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_