arcwelding_cli.hpp

 
#pragma once
#ifndef XCORESDK_SRC_MANAGED_ARCWELDING_CLI_HPP_
#define XCORESDK_SRC_MANAGED_ARCWELDING_CLI_HPP_
 
#include <unordered_map>
#include "data_types_cli.hpp"
#include "exception_cli.hpp"
#include "data_types_cli.hpp"
 
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Runtime::InteropServices;
 
namespace rokae {
class ArcWelding;
}
 
namespace rokae::clr
{
public
    ref class ArcWelding
    {
    public:
        ArcWelding(rokae::ArcWelding *arcwelding);
        ~ArcWelding();
 
        enum class WeldMode {
            TestRun = 0,
            Simu = 1,
            Real = 2
        };
 
        enum class DirType {
          X_Plus_Y_Plus = 0,
          X_Plus_Z_Plus = 1,
          Y_Plus_Z_Plus = 2
        };
 
        enum class WeldOffsetJogDir {
          Y_PLUS = 0,
          Y_MINUS = 1,
          Z_PLUS = 2,
          Z_MINUS = 3
        };
 
        value struct ReArcOnParam {
          Boolean enable;
          Int32 retry_time;
          Int32 wire_retract_delay_time;
          Int32 wire_retract_time;//<
          Double current_step;//<
          Double voltage_step;//<
 
          static ReArcOnParam CreateDefault() {
            ReArcOnParam param;
            param.enable = false;
            param.retry_time = 3;
            param.wire_retract_delay_time = 50;
            param.wire_retract_time = 200;
            param.current_step = 0.0;
            param.voltage_step = 0.0;
            return param;
          }
        };
 
        value struct ScratchArconParam {
            Boolean enable;
            Int32 distance;
            Int32 back_speed;
            Int32 step;
 
            static ScratchArconParam CreateDefault() {
                ScratchArconParam param;
                param.enable = false;
                param.distance = 20;
                param.back_speed = 50;
                param.step = 5;
                return param;
            }
        };
 
        value struct ArcOnData {
            String ^ name;
            String ^ annotation;
            String ^ mode;
            String ^ current_mode;
            String ^ voltage_mode;
            Double current;
            Double voltage;
            Int32 hold_time;
            Int32 detect_time;
            Int32 confirm_time;
            Int32 preflow_time;
            Int32 prearc_time;
            Double slow_wire_feed_speed;
            Int32 pre_wirefeed_time;
            Int32 ramp_time;
            ReArcOnParam re_arcon;
            ScratchArconParam scratch_arcon;
 
            static ArcOnData CreateDefault() {
                ArcOnData param;
                param.name = "default";
                param.annotation = "";
                param.mode = "flat_characteristic";
                param.current_mode = "current";
                param.voltage_mode = "unified";
                param.current = 0;
                param.voltage = 0;
                param.hold_time = 200;
                param.detect_time = 2000;
                param.confirm_time = 200;
                param.preflow_time = 200;
                param.prearc_time = 200;
                param.slow_wire_feed_speed = 1;
                param.pre_wirefeed_time = 200;
                param.ramp_time = 200;
                param.re_arcon = ReArcOnParam::CreateDefault();
                param.scratch_arcon = ScratchArconParam::CreateDefault();
                return param;
            }
        };
 
        value struct ArcBreakParam {
            Int32 detect_time;
            String ^ arc_break_option;
            Int32 restart_back_distance;
 
            static ArcBreakParam CreateDefault() {
                ArcBreakParam param;
                param.detect_time = 100;
                param.arc_break_option = "stop_and_alarm";
                param.restart_back_distance = 10;
                return param;
            }
        };
 
        value struct ArcData {
            String ^ name;
            String ^ annotation;
            String ^ mode;
            String ^ current_mode;
            String ^ voltage_mode;
            Double current;
            Double voltage;
            Double weld_speed;
            Int32 ramp_time;
            ArcBreakParam arc_break_param;
 
            static ArcData CreateDefault() {
                ArcData param;
                param.name = "default";
                param.annotation = "";
                param.mode = "flat_characteristic";
                param.current_mode = "current";
                param.voltage_mode = "unified";
                param.current = 0;
                param.voltage = 0;
                param.weld_speed = 10;
                param.ramp_time = 200;
                param.arc_break_param = ArcBreakParam::CreateDefault();
                return param;
            }
        };
 
        value struct AntiWireStickParam {
            Boolean enable;
            Double current;
            Double voltage;
            Int32 time;
 
            static AntiWireStickParam CreateDefault() {
                AntiWireStickParam param;
                param.enable = false;
                param.current = 30;
                param.voltage = 10;
                param.time = 500;
                return param;
            }
        };
 
        value struct ArcOffData {
            String ^ name;
            String ^ annotation;
            String ^ mode;
            String ^ current_mode;
            String ^ voltage_mode;
            Double current;
            Double voltage;
            Int32 hold_time;
            Int32 delay_gasoff_time;
            Int32 detect_time;
            Int32 retract_time;
            Int32 wire_stick_detection_time;
            AntiWireStickParam anti_wire_stick_param;
 
            static ArcOffData CreateDefault() {
                ArcOffData param;
                param.name = "default";
                param.annotation = "";
                param.mode = "flat_characteristic";
                param.current_mode = "current";
                param.voltage_mode = "unified";
                param.current = 0;
                param.voltage = 0;
                param.hold_time = 500;
                param.delay_gasoff_time = 200;
                param.detect_time = 5000;
                param.retract_time = 100;
                param.wire_stick_detection_time = 500;
                param.anti_wire_stick_param = AntiWireStickParam::CreateDefault();
                return param;
            }
        };
 
        value struct Amplitude {
            Double left;
            Double right;
 
            static Amplitude CreateDefault() {
                Amplitude param;
                param.left = 0.1;
                param.right = 0.1;
                return param;
            }
        };
 
        value struct ElevationAngle {
            Double left;
            Double right;
 
            static ElevationAngle CreateDefault() {
                ElevationAngle param;
                param.left = 0;
                param.right = 0;
                return param;
            }
        };
 
        value struct WeaveData {
            String ^ name;
            String ^ annotation;
            String ^ weaving_reference;
            String ^ pattern;
            Double weave_length_frequency;
            Amplitude amplitude;
            String ^ dwell_type;
            array<Int32> ^ dwell_time;
            Double radius;
            Boolean phase_invert;
            String ^ elevation_type;
            ElevationAngle elevation_angle;
            Double inclination_angle;
            Double acc;
            Double jerk;
 
            static WeaveData CreateDefault() {
                WeaveData param;
                param.name = "default";
                param.annotation = "";
                param.weaving_reference = "cycle";
                param.pattern = "triangular";
                param.weave_length_frequency = 0.1;
                param.amplitude = Amplitude::CreateDefault();
                param.dwell_type = "robot_stay";
                param.dwell_time = gcnew array<Int32>{0, 0, 0};
                param.radius = 0.1;
                param.phase_invert = false;
                param.elevation_type = "v_pattern";
                param.elevation_angle = ElevationAngle::CreateDefault();
                param.inclination_angle = 0;
                param.acc = 0.5;
                param.jerk = 5;
                return param;
            }
        };
 
        value struct WeaveAdaptiveData {
            Boolean isAdaptive;
            Double groove_width_standard;
            Double groove_width_ratio;
            Double max_groove_width;
            Double max_electric;
            Double max_speed;
 
            static WeaveAdaptiveData CreateDefault() {
                WeaveAdaptiveData param;
                param.isAdaptive = false;
                param.groove_width_standard = 4.00;
                param.groove_width_ratio = 4.00;
                param.max_groove_width = 6.00;
                param.max_electric = 300.00;
                param.max_speed = 8.00;
                return param;
            }
        };
 
        value struct SegData {
            String ^ name;
            String ^ annotation;
            String ^ seg_type;
            String ^ non_welded_speed;
            Double welded_distance;
            Double non_welded_distance;
 
            static SegData CreateDefault() {
                SegData param;
                param.name = "default";
                param.annotation = "";
                param.seg_type = "normal";
                param.non_welded_speed = "v5";
                param.welded_distance = 0.1;
                param.non_welded_distance = 0.1;
                return param;
            }
        };
 
        value struct LayerData {
          String ^ name;
          String ^ annotation;
 
          Double start_offset;
          Double end_offset;
          Double y_offset;
          Double z_offset;
          Double travel_angle;
          Double tilt_angle;
 
          Int32 z_axis_fixed_type;
          Int32 point_num;
          Int32 axis_type;
          Int32 aux_type;
          Int32 offset_coord_system;
 
          // 自定义向量（托管数组，长度 3，单位 mm）
          array<Double> ^ custom_point_1;
          array<Double> ^ custom_point_2;
          array<Double> ^ custom_point_3;
 
          // 辅助点位（托管数组，长度 3，单位 mm）
          array<Double> ^ aux_point_1;
          array<Double> ^ aux_point_2;
          array<Double> ^ aux_point_3;
 
          // 辅助点示教次数
          Int32 check_aux_point_count_1;
          Int32 check_aux_point_count_2;
          Int32 check_aux_point_count_3;
 
          static LayerData CreateDefault() {
            LayerData param;
            param.name = "default";
            param.annotation = "";
 
            param.start_offset = 0.0;
            param.end_offset = 0.0;
            param.y_offset = 0.0;
            param.z_offset = 0.0;
            param.travel_angle = 0.0;
            param.tilt_angle = 0.0;
 
            param.z_axis_fixed_type = 0;
            param.point_num = 0;
            param.axis_type = 0;
            param.aux_type = 0;
            param.offset_coord_system = 0;
 
            // 初始化托管数组（长度 3）
            param.custom_point_1 = gcnew array<Double>{0.0, 0.0, 0.0};
            param.custom_point_2 = gcnew array<Double>{0.0, 0.0, 0.0};
            param.custom_point_3 = gcnew array<Double>{0.0, 0.0, 0.0};
 
            param.aux_point_1 = gcnew array<Double>{0.0, 0.0, 0.0};
            param.aux_point_2 = gcnew array<Double>{0.0, 0.0, 0.0};
            param.aux_point_3 = gcnew array<Double>{0.0, 0.0, 0.0};
 
            param.check_aux_point_count_1 = 0;
            param.check_aux_point_count_2 = 0;
            param.check_aux_point_count_3 = 0;
 
            return param;
          }
        };
 
 
        value struct LaserTrackData {
            String ^ name;  
            Int32 job_number;
            Boolean y_comp;
            Boolean z_comp;
            double max_invalid_length;
 
            static LaserTrackData CreateDefault() {
                LaserTrackData param;
                param.name = "default";
                param.job_number = 0;
                param.y_comp = false;
                param.z_comp = false;
                param.max_invalid_length = 10;
                return param;
            }
        };
 
        value struct LaserSearchData {
            String ^ name;
            Int32 job_number;
            String ^ search_type;
            String ^ search_mode;
            Double step_length;
            String ^ joint_type;
 
            static LaserSearchData CreateDefault() {
                LaserSearchData param;
                param.name = "default";
                param.job_number = 0;
                param.search_type = "point";
                param.search_mode = "continuous";
                param.step_length = 2.0;
                param.joint_type = "corner_joint";
                return param;
            }
        };
 
        value struct IOData {
            String ^ name;
            Int32 type;
            Int32 bias;
            Boolean enable;
 
            static IOData CreateDefault() {
                IOData param;
                param.name = "";
                param.type = 0;
                param.bias = 0;
                param.enable = false;
                return param;
            }
        };
 
        value struct IOSetting {
            IOData arc_on;
            IOData wire_feed;
            IOData wire_feed_back;
            IOData gas_test;
            IOData positioning_enable;
            IOData arc_on_success;
            IOData positioning_feedback;
            IOData current_set;
            IOData voltage_set;
            IOData current_get;
            IOData voltage_get;
            IOData robot_ready;
            IOData error;
 
            static IOSetting CreateDefault() {
                IOSetting param;
                param.arc_on = IOData::CreateDefault();
                param.wire_feed = IOData::CreateDefault();
                param.wire_feed_back = IOData::CreateDefault();
                param.gas_test = IOData::CreateDefault();
                param.positioning_enable = IOData::CreateDefault();
                param.arc_on_success = IOData::CreateDefault();
                param.positioning_feedback = IOData::CreateDefault();
                param.current_set = IOData::CreateDefault();
                param.voltage_set = IOData::CreateDefault();
                param.current_get = IOData::CreateDefault();
                param.voltage_get = IOData::CreateDefault();
                param.robot_ready = IOData::CreateDefault();
                param.error = IOData::CreateDefault();
                return param;
            }
        };
 
        value struct CharacteristicCurveData {
            String ^ name;
            Double intercept;
            List<Tuple<Double, Double> ^> ^ points;
            Double slope;
 
            static CharacteristicCurveData CreateDefault() {
                CharacteristicCurveData param;
                param.name = "default";
                param.intercept = 0;
                param.points = gcnew List<Tuple<Double, Double> ^>();
                param.slope = 0;
                return param;
            }
        };
 
        value struct ArcWeldRunningParam {
            Double test_run_speed;
            Double wire_feed_speed;
            Int32 gas_detect_time;
 
            static ArcWeldRunningParam CreateDefault() {
                ArcWeldRunningParam param;
                param.test_run_speed = 200;
                param.wire_feed_speed = 1;
                param.gas_detect_time = 15;
                return param;
            }
        };
 
        value struct WelderStatus {
            Double current;
            Double voltage;
            String ^ state;
            Int32 speed;
            ErrorCode ^ running_error;
            String ^ welding_name;
            Int32 arc_welding;
            Double welding_distance;
            Int32 welding_path_num;
            Double welding_time;
            Double welding_wire_used;
            Int32 welder_error_code;
            bool welder_ready;
 
 
            static WelderStatus CreateDefault() {
                WelderStatus param;
                param.current = 0;
                param.voltage = 0;
                param.state = "disabled";
                param.speed = 0;
                param.running_error = gcnew ErrorCode(0, "操作成功完成");
                param.welding_name = "";
                param.arc_welding = -1;
                param.welding_distance = 0;
                param.welding_path_num = 0;
                param.welding_time = 0;
                param.welding_wire_used = 0;
                param.welder_error_code = 0;
                param.welder_ready = false;
                return param;
            }
        };
 
        value struct WelderSetting {
            String ^ mfr;
            String ^ model;
            String ^ protocol;
            Int32 current_type;
            String ^ current_file;
            String ^ voltage_file;
            double wire_diameter;
            String ^ shielding_gas;
            int program_number;
            int dry_extension;
 
            static WelderSetting CreateDefault() {
                WelderSetting param;
                param.mfr = "";
                param.model = "";
                param.protocol = "";
                param.current_type = 0;
                param.current_file = "";
                param.voltage_file = "";
                param.wire_diameter = 0;
                param.shielding_gas = "";
                param.program_number = 0;
                param.dry_extension = 0;
                return param;
            }
        };
 
        value struct HandeyeData {
            String ^ name;
            Boolean mode;
            array<Double> ^ xyz_abc;
            array<Double> ^ rotMatrix;
            array<Double> ^ transVector;
 
            static HandeyeData CreateDefault() {
                HandeyeData param;
                param.name = "";
                param.mode = false;
                param.xyz_abc = gcnew array<Double>{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
                param.rotMatrix = gcnew array<Double>{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
                param.transVector = gcnew array<Double>{0.0, 0.0, 0.0};
                return param;
            }
        };
 
        value struct CalibrationResult{
            int id;
            List<double>^ p_robot;
            List<double>^ p_laser;
 
            static CalibrationResult CreateDefault(){
                CalibrationResult param;
                param.id = 0;
                param.p_robot = gcnew List<double>();
                param.p_laser = gcnew List<double>();
                return param;
            }
        };
 
        enum class LaserSensorType {
            CRNT = 0,
            SMART_IMAGE = 1,
            INTELLIGENT = 2
        };
 
        value struct LaserSensorCfg {
            String ^ name;
            String ^ ip;
            Int32 port;
            LaserSensorType type;
            Int32 overtime;
            Int32 communication_cycle;
 
            static LaserSensorCfg CreateDefault() {
                LaserSensorCfg param;
                param.name = "sensor0";
                param.ip = "192.168.2.3";
                param.port = 502;
                param.type = LaserSensorType::CRNT;
                param.overtime = 1000;
                param.communication_cycle = 70;
                return param;
            }
        };
 
        value struct LrTrackParam {
          double pid;
          double curr_bias_offset;
          double min_compensation;
          double max_compensation;
 
          static LrTrackParam CreateDefault() {
            LrTrackParam param;
            param.pid = 5.0;
            param.curr_bias_offset = 5.0;
            param.min_compensation = 0.01;
            param.max_compensation = 0.7;
            return param;
          }
        };
 
        value struct UdTrackParam {
          double pid;
          double curr_bias_offset;
          double min_compensation;
          double max_compensation;
          double base_current;
          int sampling_start_period;
          int sampling_duration_period;
 
          static UdTrackParam CreateDefault() {
            UdTrackParam param;
            param.pid = 5.0;
            param.curr_bias_offset = 5.0;
            param.min_compensation = 0.01;
            param.max_compensation = 0.7;
            param.base_current = 0.0;
            param.sampling_start_period = 5;
            param.sampling_duration_period = 1;
            return param;
          }
        };
 
        value struct ArcTrackParam {
          String ^ name;
          String ^ annotation;
          int delay_time;
          int cycle;
          bool lr_enable;
          bool ud_enable;
          LrTrackParam lr_param;
          UdTrackParam ud_param;
 
          static ArcTrackParam CreateDefault() {
            ArcTrackParam param;
            param.name = "";
            param.annotation = "";
            param.delay_time = 0;
            param.cycle = 6;
            param.lr_enable = false;
            param.ud_enable = false;
            param.lr_param = LrTrackParam::CreateDefault();
            param.ud_param = UdTrackParam::CreateDefault();
            return param;
          }
        };
 
        value struct ArcSetOpt {
            String ^ arc_data;
            Boolean ref_start;
            Double distance;
 
            static ArcSetOpt CreateDefault() {
                ArcSetOpt param;
                param.arc_data = "";
                param.ref_start = true;
                param.distance = 0;
                return param;
            }
        };
 
        value struct AnticollisionState{
            String^ signal;
            Boolean enable;
            Boolean block;
            Int32 countdown;
 
            static AnticollisionState CreateDefault() {
                AnticollisionState param;
                param.signal = "";
                param.enable = false;
                param.block = false;
                param.countdown = 60;
                return param;
            }
        };
 
        ArcOnData getArcOnData(String ^ arconDataName, [Out] ErrorCode ^ % ec);
 
        void setArcOnData(ArcOnData arconData, [Out] ErrorCode ^ % ec);
 
        void removeArcOnData(String ^ arconDataName, [Out] ErrorCode ^ % ec);
 
        void removeArcOnData(List<String ^> ^ arconDataNames, [Out] ErrorCode ^ % ec);
 
        ArcData getArcData(String ^ arcDataName, [Out] ErrorCode ^ % ec);
 
        void setArcData(ArcData arcData, [Out] ErrorCode ^ % ec);
 
        void removeArcData(String ^ arcDataName, [Out] ErrorCode ^ % ec);
 
        void removeArcData(List<String ^> ^ arcDataNames, [Out] ErrorCode ^ % ec);
 
        void enableArcData(ArcData arcData, [Out] ErrorCode ^ % ec);
 
        ArcOffData getArcOffData(String ^ arcoffDataName, [Out] ErrorCode ^ % ec);
 
        void setArcOffData(ArcOffData arcoffData, [Out] ErrorCode ^ % ec);
 
        void removeArcOffData(String ^ arcoffDataName, [Out] ErrorCode ^ % ec);
 
        void removeArcOffData(List<String ^> ^ arcoffDataNames, [Out] ErrorCode ^ % ec);
 
        WeaveData getWeaveData(String ^ weaveDataName, [Out] ErrorCode ^ % ec);
 
        void setWeaveData(WeaveData weaveData, [Out] ErrorCode ^ % ec);
 
        void removeWeaveData(String ^ weaveDataName, [Out] ErrorCode ^ % ec);
 
        void removeWeaveData(List<String ^> ^ weaveDataNames, [Out] ErrorCode ^ % ec);
 
        WeaveAdaptiveData getWeaveAdaptiveData([Out] ErrorCode^% ec);
 
        void setWeaveAdaptiveData(WeaveAdaptiveData weaveAdaptiveData, [Out] ErrorCode^% ec);
 
        SegData getSegData(String^ segDataName, [Out] ErrorCode ^ % ec);
 
        void setSegData(SegData segData, [Out] ErrorCode ^ % ec);
 
        void removeSegData(String^ segDataName, [Out] ErrorCode ^ % ec);
 
        void removeSegData(List<String^>^ segDataNames, [Out] ErrorCode ^ % ec);
 
        LayerData getLayerData(String ^ layerDataName, [Out] ErrorCode ^ % ec);
 
        void setLayerData(LayerData layerData, [Out] ErrorCode ^ % ec);
 
        void removeLayerData(String ^ layerDataName, [Out] ErrorCode ^ % ec);
 
        void removeLayerData(List<String ^> ^ layerDataNames, [Out] ErrorCode ^ % ec);
 
        LaserTrackData getLaserTrackData(String^ laserTrackDataName, [Out] ErrorCode ^ % ec);
 
        void setLaserTrackData(LaserTrackData laserTrackData, [Out] ErrorCode ^ % ec);
 
        void removeLaserTrackData(String^ laserTrackDataName, [Out] ErrorCode ^ % ec);
 
        void removeLaserTrackData(List<String^>^ laserTrackDataNames, [Out] ErrorCode ^ % ec);
 
        LaserSearchData getLaserSearchData(String^ laserSearchDataName, [Out] ErrorCode ^ % ec);
 
        void setLaserSearchData(LaserSearchData laserSearchData, [Out] ErrorCode ^ % ec);
 
        void removeLaserSearchData(String^ laserSearchDataName, [Out] ErrorCode ^ % ec);
 
        void removeLaserSearchData(List<String^>^ laserSearchDataNames, [Out] ErrorCode ^ % ec);
 
        IOSetting getIOSetting([Out] ErrorCode ^ % ec);
 
        void setIOSetting(IOSetting ioSetting, [Out] ErrorCode ^ % ec);
 
        CharacteristicCurveData getCurrentCharacteristicCurveData(String^ name, [Out] ErrorCode ^ % ec);
 
        void setCurrentCharacteristicCurveData(CharacteristicCurveData data, [Out] ErrorCode ^ % ec);
 
        CharacteristicCurveData getVoltageCharacteristicCurveData(String^ name, [Out] ErrorCode ^ % ec);
 
        void setVoltageCharacteristicCurveData(CharacteristicCurveData data, [Out] ErrorCode ^ % ec);
 
        CharacteristicCurveData calculateCurrentCurve(CharacteristicCurveData data, [Out] ErrorCode ^ % ec);
 
        CharacteristicCurveData calculateVoltageCurve(CharacteristicCurveData data, [Out] ErrorCode ^ % ec);
 
        WelderStatus getWelderStatus([Out] ErrorCode ^ % ec);
 
        void setWelder(String^ protocol, String^  mfr, String^  type, Int32 current, [Out] ErrorCode ^ % ec);
 
        void setWelder(ArcWelding::WelderSetting welderSetting, [Out] ErrorCode ^ % ec);
 
        WelderSetting getWelderSetting([Out] ErrorCode ^ % ec);
 
        void connectToWelder([Out] ErrorCode ^ % ec);
 
        void disconnectFromWelder([Out] ErrorCode ^ % ec);
 
        Boolean isEniHaveWeld([Out] ErrorCode ^ % ec);
 
        void setIsEniHaveWeld(Boolean isEniHaveWeld, [Out] ErrorCode ^ % ec);
 
        WeldMode getWeldMode([Out] ErrorCode ^ % ec);
 
        void setWeldMode(WeldMode weldMode, [Out] ErrorCode ^ % ec);
 
        ArcWeldRunningParam getRunningParam([Out] ErrorCode ^ % ec);
 
        void setRunningParam(ArcWeldRunningParam data, [Out] ErrorCode ^ % ec);
 
        void feedOnWire(Double time, Boolean enable, [Out] ErrorCode ^ % ec);
 
        void feedBackWire(Double time, Boolean enable, [Out] ErrorCode ^ % ec);
 
        void detectGas(Double time, Boolean enable, [Out] ErrorCode ^ % ec);
 
        void setCurrentAndVoltage(Double current, Double voltage, [Out] ErrorCode ^ % ec);
 
        void saveCurrentAndVoltage(Double current, Double voltage, [Out] ErrorCode ^ % ec);
 
        void startWelding(Double current, Double voltage, String^ voltage_mode, [Out] ErrorCode ^ % ec);
 
        void startWelding(Double current, Double voltage, String^ voltage_mode, String^ current_mode, String^ work_mode, [Out] ErrorCode ^ % ec);
 
        void stopWelding([Out] ErrorCode ^ % ec);
 
        void clearWelderAlarm([Out] ErrorCode ^ % ec);
 
        void setHandeyeData(HandeyeData handeyedata, [Out] ErrorCode ^ % ec);
 
        HandeyeData getHandeyeData(String^ name, [Out] ErrorCode ^ % ec);
 
        void removeHandeyeData(String^ name, [Out] ErrorCode ^ % ec);
 
        void removeHandeyeData(List<String^>^ names, [Out] ErrorCode ^ % ec);
 
        void startHandeyeCalibration(String ^ name, int type, [Out] ErrorCode ^ % ec);
 
        CalibrationResult calibratePoint(int id, [Out] ErrorCode ^ % ec);
 
        List<double> ^ calibrateEnd(HandeyeData% handeyedata, [Out] ErrorCode ^ % ec);
 
        void setLaserSensorCfg(LaserSensorCfg cfg, [Out] ErrorCode ^ % ec);
 
        LaserSensorCfg getLaserSensorCfg(String^ name, [Out] ErrorCode ^ % ec);
 
        void removeLaserSensorCfg(String^ device_name, [Out] ErrorCode ^ % ec);
 
        void removeLaserSensorCfg(List<String^>^ device_names, [Out] ErrorCode ^ % ec);
 
        void connLaserSensorDev(String^ device_name, [Out] ErrorCode ^ % ec);
 
        void disconnLaserSensorDev(String^ device_name, [Out] ErrorCode ^ % ec);
 
        void openLaserTrack(String^ device_name, [Out] ErrorCode ^ % ec);
 
        void closeLaserTrack(String^ device_name, [Out] ErrorCode ^ % ec);
 
        void setArcTrackParam(ArcTrackParam param, [Out] ErrorCode ^ % ec);
 
        ArcTrackParam getArcTrackParam(String ^ name, [Out] ErrorCode ^ % ec);
 
        void removeArcTrackParam(String ^ name, [Out] ErrorCode ^ % ec);
 
        void removeArcTrackParam(List<String^>^ names, [Out] ErrorCode ^ % ec);
 
        void setAnticollision(String^ signal, Boolean enable, Boolean block, Int32 countdown, [Out] ErrorCode ^ % ec);
 
        AnticollisionState getAnticollisionState([Out] ErrorCode ^ % ec);
 
        array<String^>^ getWelderWorkModes([Out] ErrorCode ^ % ec);
 
        void weldOffsetJog(WeldOffsetJogDir dir, [Out] ErrorCode ^ % ec);
 
        ref class ArcWeldingCommand{};
 
        ref class ArcOnCommand : public ArcWeldingCommand
        {
        public:
            ArcOnCommand();
 
            ArcOnCommand(String^ arcOnData, String^ arcData);
 
            void setArcOnData(String^ arcOnData, [Out] ErrorCode ^ % ec);
 
            String^  getArcOnData();
 
            void setArcData(String^ arcData, [Out] ErrorCode ^ % ec);
 
            String^  getArcData();
 
        private:
            String^  m_arcOnData{"default"}; 
            String^  m_arcData{"default"};   
        };
 
        ref class ArcOffCommand : public ArcWeldingCommand
        {
        public:
            ArcOffCommand();
 
            ArcOffCommand(String^ arcOffData);
 
            void setArcOffData(String^ arcOffData, [Out] ErrorCode ^ % ec);
 
            String^  getArcOffData();
 
        private:
            String^  m_arcOffData{"default"}; 
        };
 
        ref class FeedOnWireCommand : public ArcWeldingCommand {
         public:
          FeedOnWireCommand();
 
          FeedOnWireCommand(Double time, Double speed, Boolean isFeed);
 
          void setFeedOnWireData(Double time, Double speed, Boolean isFeed, [Out] ErrorCode ^ % ec);
 
          void getFeedOnWireData(Double % time, Double % speed, Boolean % isFeed);
 
         private:
          Double m_time;    
          Double m_speed { 1.0 };   
          Boolean m_isFeed { true };  
        };
 
        ref class FeedBackWireCommand : public ArcWeldingCommand {
         public:
          FeedBackWireCommand();
 
          FeedBackWireCommand(Double time, Double speed, Boolean isReverse);
 
          void setFeedBackWireData(Double time, Double speed, Boolean isReverse, [Out] ErrorCode ^ % ec);
 
          void getFeedBackWireData(Double % time, Double % speed, Boolean % isReverse);
 
         private:
          Double m_time;    
          Double m_speed { 1.0 };   
          Boolean m_isReverse { true };   
        };
 
        ref class WMoveLCommand : public ArcWeldingCommand
        {
        public:
            WMoveLCommand();
 
            WMoveLCommand(CartesianPosition ^ target, Int32 speed, Int32 zone): target(target), speed(speed), zone(zone), m_weaveData(""), m_trackData(""){};
 
            WMoveLCommand(CartesianPosition ^ target, Int32 speed, Int32 zone, String ^ weaveData): target(target), speed(speed), zone(zone), m_weaveData(weaveData), m_trackData(""){};
 
            WMoveLCommand(CartesianPosition ^ target, Int32 speed, Int32 zone, String ^ weaveData, String ^ trackData);
 
            void setWeaveData(String ^ weaveData, [Out] ErrorCode ^ % ec);
 
            String ^ getWeaveData();
 
            void setTrackData(String ^ trackData, [Out] ErrorCode ^ % ec);
 
            String ^ getTrackData();
 
            CartesianPosition ^ target = gcnew CartesianPosition();
            Int32 speed = -1;
            Int32 zone = -1;
            CartesianPosition::Offset ^ cartTargetOffset = gcnew CartesianPosition::Offset();
            double rotSpeed = -1;
            String ^ customInfo = "";
            ArcSetOpt arc_set_opt = ArcSetOpt::CreateDefault();
 
        private:
            String ^ m_weaveData = "";
            String ^ m_trackData = "";
        };
 
        ref class WMoveCCommand : public ArcWeldingCommand
        {
        public:
            WMoveCCommand();
 
            WMoveCCommand(CartesianPosition ^ target, CartesianPosition ^ aux, Int32 speed, Int32 zone): target(target), aux(aux), speed(speed), zone(zone), m_weaveData(""), m_trackData(""){};
 
            WMoveCCommand(CartesianPosition ^ target, CartesianPosition ^ aux, Int32 speed, Int32 zone, String ^ weaveData): target(target), aux(aux), speed(speed), zone(zone), m_weaveData(weaveData), m_trackData(""){};
 
            WMoveCCommand(CartesianPosition ^ target, CartesianPosition ^ aux, Int32 speed, Int32 zone, String ^ weaveData, String ^ trackData);
 
            void setWeaveData(String ^ weaveData, [Out] ErrorCode ^ % ec);
 
            String ^ getWeaveData();
 
            void setTrackData(String ^ trackData, [Out] ErrorCode ^ % ec);
 
            String ^ getTrackData();
 
            CartesianPosition ^ target = gcnew CartesianPosition();
            CartesianPosition ^ aux = gcnew CartesianPosition();
            CartesianPosition::Offset ^ cartTargetOffset = gcnew CartesianPosition::Offset();
            CartesianPosition::Offset ^ auxPointOffset = gcnew CartesianPosition::Offset();
            Int32 speed = -1;
            Int32 zone = -1;
            double rotSpeed = -1;
            String ^ customInfo = "";
            ArcSetOpt arc_set_opt = ArcSetOpt::CreateDefault();
 
        private:
            String ^ m_weaveData = "";
            String ^ m_trackData = "";
        };
 
        ref class WMoveCFCommand : public ArcWeldingCommand{
            public:
            WMoveCFCommand();
 
            WMoveCFCommand(CartesianPosition ^ target, CartesianPosition ^ aux, double angle, Int32 speed, Int32 zone): target(target), aux(aux), angle(angle), speed(speed), zone(zone), m_weaveData(""), m_trackData(""){};
 
            WMoveCFCommand(CartesianPosition ^ target, CartesianPosition ^ aux, double angle, Int32 speed, Int32 zone, String ^ weaveData): target(target), aux(aux), angle(angle), speed(speed), zone(zone), m_weaveData(weaveData), m_trackData(""){};
 
            WMoveCFCommand(CartesianPosition ^ target, CartesianPosition ^ aux, double angle, Int32 speed, Int32 zone, String ^ weaveData, String ^ trackData);
 
            void setWeaveData(String ^ weaveData, [Out] ErrorCode ^ % ec);
 
            String ^ getWeaveData();
 
            void setTrackData(String ^ trackData, [Out] ErrorCode ^ % ec);
 
            String ^ getTrackData();
 
            CartesianPosition ^ target = gcnew CartesianPosition();
            CartesianPosition ^ aux = gcnew CartesianPosition();
            CartesianPosition::Offset ^ cartTargetOffset = gcnew CartesianPosition::Offset();
            CartesianPosition::Offset ^ auxPointOffset = gcnew CartesianPosition::Offset();
            Int32 speed = -1;
            Int32 zone = -1;
            double rotSpeed = -1;
            String ^ customInfo = "";
            double angle = 0;
            int rotType = 0;
            ArcSetOpt arc_set_opt = ArcSetOpt::CreateDefault();
 
        private:
            String ^ m_weaveData = "";
            String ^ m_trackData = "";
        };
 
        ref class WMoveLPendulumCommand : public ArcWeldingCommand
        {
        public:
            WMoveLPendulumCommand();
 
            WMoveLPendulumCommand(CartesianPosition^ startAux, CartesianPosition^ targetAux, CartesianPosition^ target, Int32 speed, Double frequency, Double dwellTimeLeft, Double dwellTimeRight );
 
            WMoveLPendulumCommand(CartesianPosition^ targetAux, CartesianPosition^ target, Int32 speed, Double frequency, Double dwellTimeLeft, Double dwellTimeRight );
 
            CartesianPosition^ startAux = gcnew CartesianPosition();
            CartesianPosition^ targetAux = gcnew CartesianPosition();
            CartesianPosition^ target = gcnew CartesianPosition();
            CartesianPosition::Offset^ startAuxTPointOffset = gcnew CartesianPosition::Offset();
            CartesianPosition::Offset^ targetAuxPointOffset = gcnew CartesianPosition::Offset();
            CartesianPosition::Offset^ targetPointOffset = gcnew CartesianPosition::Offset();
            Int32 speed = -1;
            Double frequency;
            Double dwellTimeLeft;
            Double dwellTimeRight;
            double rotSpeed = -1;
            ArcSetOpt arc_set_opt = ArcSetOpt::CreateDefault();
            bool nonLeadingPendulum;
        };
 
        ref class WeaveOnCommand : public ArcWeldingCommand
        {
        public:           
            WeaveOnCommand();
 
            WeaveOnCommand(String^ weaveData);
 
            void setWeaveData(String^ weaveData, [Out] ErrorCode ^ % ec);
 
            String^  getWeaveData();
 
        private:
            String^  m_weaveData{"default"};
        };
 
        ref class WeaveOffCommand : public ArcWeldingCommand
        {
        };
 
        ref class OffsetOnCommand : public ArcWeldingCommand {
         public:
          OffsetOnCommand();
 
          OffsetOnCommand(String ^ layerData);
 
          OffsetOnCommand(String ^ layerData, Int32 rpm);
 
          void setOffsetOnData(String ^ layerData, [Out] ErrorCode ^ % ec);
          
          void setOffsetOnData(String ^ layerData, Int32 rpm, [Out] ErrorCode ^ % ec);
 
          String ^ m_layerData { "default" };
          Int32 m_rpm { 0 };
        };
 
        ref class OffsetOffCommand : public ArcWeldingCommand {};
 
        ref class ChangeLayerDataCommand : public ArcWeldingCommand {
         public:
 
 
          ChangeLayerDataCommand();
 
 
          ChangeLayerDataCommand(String ^ layerDataName, Double startOffset, Double endOffset, Double yOffset, Double zOffset, Double travelAngle, Double tiltAngle);
 
          ArcWelding::LayerData ^ getChangeLayerData();
 
          private:
           ArcWelding::LayerData ^ m_layerData;
        };
 
        ref class LaserTrackOnCommand : public ArcWeldingCommand
        {
        public:
            LaserTrackOnCommand();
 
            LaserTrackOnCommand(String^ handEyeData, String^  laserTrackData);
 
            void setHandEyeData(String^ handEyeData, [Out] ErrorCode ^ % ec);
 
            String^  getHandEyeData();
 
            void setLaserTrackData(String^ laserTrackData, [Out] ErrorCode ^ % ec);
 
            String^  getLaserTrackData();
 
        private:
            String^  m_handEyeData{"default"}; 
            String^  m_laserTrackData{"default"};
        };
 
        ref class LaserTrackOffCommand : public ArcWeldingCommand
        {
        };
 
        ref class LaserSearchCommand : public ArcWeldingCommand
        {
        public:
            LaserSearchCommand();
 
            LaserSearchCommand(String^ laserHandEyeData, String^  laserSearchData, CartesianPosition^ endPoint, Int32 speed, Int32 zone);
 
        public:
            String^  laserHandEyeData = "default"; 
            String^  laserSearchData = "default";
            CartesianPosition^ endPoint = gcnew CartesianPosition();
            Int32 speed = -1;
            Int32 zone = -1;
        };
 
        ref class SegOnCommand : public ArcWeldingCommand
        {
        public:
            SegOnCommand();
 
            SegOnCommand(String^ segData);
 
            String^ segData = "default";
        };
 
        ref class SegOffCommand : public ArcWeldingCommand{};
 
        Tuple<Boolean, CartesianPosition^>^ executeLaserSearch(ArcWelding::LaserSearchCommand^ cmd, Boolean isMove, System::TimeSpan^ timeout, [Out] ErrorCode ^ % ec);
 
        CartesianPosition^ calcIntersection(array<CartesianPosition^>^ points, [Out] ErrorCode ^ % ec);
 
        CartesianPosition ^ GetLaserPos(CartesianPosition ^ pos, String ^ laserHandEyeData, [Out] ErrorCode ^ % ec, String ^ refSys);
 
        Frame ^ getRefBy3Points(array<CartesianPosition^>^ points, bool withOrigin, DirType dt, [Out] ErrorCode ^ % ec);
 
    private:
        rokae::ArcWelding *_arcwelding;
    };
}
 
#endif // XCORESDK_SRC_MANAGED_ARCWELDING_CLI_HPP_