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,
        endInWorld
    };
 
    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,
        none
    };
 
    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,
        arcWeldState,
        rlExecution,
        logReporter,
        lasertrackState,
        anticollisionState,
        schedState,
        disconnectionBehaviour,
    };
 
    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), quat(gcnew array<double>(4)) {}
 
        Frame(array<double>^ _frame) : trans(gcnew array<double>(3)), rpy(gcnew array<double>(3)),
        quat(gcnew array<double>(4)){
            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)), quat(gcnew array<double>(4)) {}
        array<double>^ trans;
        array<double>^ rpy;
        array<double> ^ quat;
    };
 
    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>) {};
 
        CartesianPosition(array<double>^ _frame):Frame(_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;
        int speed;
        double jointSpeed;
        double rotSpeed;
        int zone;
        String^ customInfo;
 
        List<double>^ args;
        bool iscondition;
        String^ io_name;
 
        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>()),
            iscondition(false), io_name(gcnew String("")) {};
    };
 
    public ref class PulseLCommand {
    public:
 
        CartesianPosition^ cartTarget;
        CartesianPosition::Offset^ cartTargetOffset;
        int speed;
        double rotSpeed;
        int zone;
        String^ customInfo;
 
        String^ signalName;
 
        double periodWidth;
 
        double pulseTime;
 
 
        PulseLCommand() : cartTarget(gcnew CartesianPosition()),
            cartTargetOffset(gcnew CartesianPosition::Offset()),
            speed(-1), rotSpeed(-1), zone(-1), customInfo(gcnew String("")), signalName(""), periodWidth(0), pulseTime(0) {
        };
    };
 
    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 ref class Toolset {
    public:
        Toolset() : load(gcnew Load()), end(gcnew Frame()), reference(gcnew Frame()) {}
        Load^ load;
        Frame^ end;
        Frame^ reference;
        String ^endName;
        String ^referenceName;
    };
 
    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;
    };
 
    public value struct SignalBinding {
        String ^ type;
        String ^ name;
    };
 
    public ref class SchedEntry {
    public:
        SchedEntry() : id(0), enable(false), name(gcnew String("")), count(1) {
            register_binding.type = gcnew String("DI");
            register_binding.name = gcnew String("");
            register_cancel.type = gcnew String("DI");
            register_cancel.name = gcnew String("");
            register_status.type = gcnew String("DO");
            register_status.name = gcnew String("");
        }
        SchedEntry(int id,
                    bool enable,
                    String ^ name,
                    int count,
                    SignalBinding register_binding,
                    SignalBinding register_cancel,
                    SignalBinding register_status) : id(id), enable(enable), name(name), count(count) {
            this->register_binding.type = register_binding.type;
            this->register_binding.name = register_binding.name;
            this->register_cancel.type = register_cancel.type;
            this->register_cancel.name = register_cancel.name;
            this->register_status.type = register_status.type;
            this->register_status.name = register_status.name;
        }
        int id;
        bool enable;
        String ^ name;
        int count;
        SignalBinding register_binding;
        SignalBinding register_cancel;
        SignalBinding register_status;
    };
 
    public ref class SchedSetting {
        public:
        SchedSetting(){
            schedEntrys = gcnew array<SchedEntry^>(8);
            for (int i = 0; i < 8; ++i) {
                schedEntrys[i] = gcnew SchedEntry(); 
                schedEntrys[i]->id = i+1;            
            }
        }
        SchedEntry^ get(int id){
            if (id < 1) return schedEntrys[0];
            else if (id > 8) return schedEntrys[7];
            return schedEntrys[id - 1];
        }
        array<SchedEntry^>^ schedEntrys;
    };
 
    public value struct SchedStatus {
        int id;
        String^ state;
        int rank;
        int count;
    };
}
#endif // XCORESDK_SRC_CLI_DATA_TYPES_CLI_HPP_