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
        };
 
        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 = 200;
                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 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 LaserTrackData {
            String ^ name;  
            Int32 job_number;
            Boolean y_comp;
            Double y_offset;
            Boolean z_comp;
            Double z_offset;
 
            static LaserTrackData CreateDefault() {
                LaserTrackData param;
                param.name = "default";
                param.job_number = 0;
                param.y_comp = false;
                param.y_offset = 20;
                param.z_comp = false;
                param.z_offset = 20;
                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;
 
            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;
                return param;
            }
        };
 
        value struct WelderSetting {
            String ^ mfr;
            String ^ model;
            String ^ protocol;
            Int32 current_type;
            String ^ current_file;
            String ^ voltage_file;
 
            static WelderSetting CreateDefault() {
                WelderSetting param;
                param.mfr = "";
                param.model = "";
                param.protocol = "";
                param.current_type = 0;
                param.current_file = "";
                param.voltage_file = "";
                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
        };
 
        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 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);
 
        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);
 
        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 stopWelding([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 setAnticollision(String^ signal, Boolean enable, Boolean block, Int32 countdown, [Out] ErrorCode ^ % ec);
 
        AnticollisionState getAnticollisionState([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 WMoveLCommand : public ArcWeldingCommand
        {
        public:
            WMoveLCommand();
 
            WMoveLCommand(CartesianPosition ^ target, Int32 speed, Int32 zone, String ^ weaveData);
 
            void setWeaveData(String ^ weaveData, [Out] ErrorCode ^ % ec);
 
            String ^ getWeaveData();
 
            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 = "";
        };
 
        ref class WMoveCCommand : public ArcWeldingCommand
        {
        public:
            WMoveCCommand();
 
            WMoveCCommand(CartesianPosition ^ target, CartesianPosition ^ aux, Int32 speed, Int32 zone, String ^ weaveData);
 
            void setWeaveData(String ^ weaveData, [Out] ErrorCode ^ % ec);
 
            String ^ getWeaveData();
 
            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 = "";
        };
 
        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 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);
 
    private:
        rokae::ArcWelding *_arcwelding;
    };
}
 
#endif // XCORESDK_SRC_MANAGED_ARCWELDING_CLI_HPP_