using Aurora.Api.Devices;
using Opc.Ua;
using Opc.Ua.Client;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace AuroraLaser
{
    class LaserTrueDisk : SocketConn, ILaser
    {
        private Session _session = null;
        private Subscription _subscription = null;

        public string strServerAddress = "opc.tcp://192.0.2.1:4840";
        public string strID = "070";
        public string strPW = "070f467";
        public bool IsConnect = false;
        private bool _IsSimul;

        public enum eSeqStep : int
        {
            SEQ_NONE = 0,
            SEQ_LASER_ON_START,
            SEQ_LASER_ON_EXT_ACTIVE_CHK,
            SEQ_LASER_RESET_ON_CHK,
            SEQ_LASER_RESET_ON_DELAY,
            SEQ_LASER_RESET_OFF_CHK,
            SEQ_LASER_ON_LASER_ON_CHK,
            SEQ_LASER_ON_READY_CHK,
            SEQ_LASER_ON_DYNAMIC_ON_CHK,
            SEQ_LASER_ON_PROG_ACTIVE_CHK,


            SEQ_LASER_OFF_START,
            SEQ_LASER_OFF_PROG_STOP_ON_CHK,
            SEQ_LASER_OFF_PROG_STOP_ON_DELAY,
            SEQ_LASER_OFF_PROG_STOP_OFF_CHK,

            SEQ_LASER_PILOT_LASER_ON_START,
            SEQ_LASER_PILOT_LASER_ON_EXT_ACTIVE_CHK,
            SEQ_LASER_PILOT_LASER_ON_RESET_ON_CHK,
            SEQ_LASER_PILOT_LASER_ON_RESET_ON_DELAY,
            SEQ_LASER_PILOT_LASER_ON_RESET_OFF_CHK,
            SEQ_LASER_PILOT_LASER_ON_PILOT_LASER_ON_CHK,

            SEQ_LASER_PILOT_LASER_OFF_START,
            SEQ_LASER_PILOT_LASER_OFF_CHK,
            SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_ON_CHK,
            SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_DELAY,
            SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_OFF_CHK,

        };

        private eSeqStep nSequence;
        public eLaserStatus nLaserStatus;

        public bool AutoProgramStart { get; set; } = false;

        Thread m_threadTrueDiskSeq = null;

        List<NodeId> readNodeIdList = null;
        List<NodeId> writeNodeIdList = null;

        //  Read/Write node information
        public sNodeInfo[] ReadNode = new sNodeInfo[100];
        public sNodeInfo[] WriteNode = new sNodeInfo[100];
        protected readonly object readNodeLock = new object();
        protected readonly object writeNodeLock = new object();

        public LaserTrueDisk(string deviceid, bool isSimul, SocketProtocol type, bool isCallBack = false) : base(deviceid, isSimul, type)
        {
            _IsSimul = isSimul;
            nLaserStatus = eLaserStatus.STATUS_NONE;
            nSequence = eSeqStep.SEQ_NONE;

            for (int i = 0; i < 100; i++) {
                ReadNode[i].nExist = 0;
                ReadNode[i].IsCallBack = isCallBack ? 1 : 0;
                ReadNode[i].nDigit = 1;
                ReadNode[i].priority = 1;   // 기본값
                WriteNode[i].nExist = 0;
                WriteNode[i].IsCallBack = isCallBack ? 1 : 0;
                WriteNode[i].nDigit = 1;
                ReadNode[i].priority = 1;   // 기본값
            }

            string strHead = "ns=2;s=";

            //----------        Read NODE
            ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.EXT_ACTIVATION_ACTIV";
            ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].strDisplayNodeName = "EXT ACTIVATION ACTIVE";
            ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].nExist = 1;
            ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].strKey = "0";
            ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].priority = 0;

            ReadNode[csReadNodeNo.LASER_WARNING_LAMP_IS_ON].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.LASER_WARNINGLAMP_IS_ON";
            ReadNode[csReadNodeNo.LASER_WARNING_LAMP_IS_ON].strDisplayNodeName = "LASER WARNING LAMP IS ON";
            ReadNode[csReadNodeNo.LASER_WARNING_LAMP_IS_ON].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.LASER_WARNING_LAMP_IS_ON].nExist = 1;
            ReadNode[csReadNodeNo.LASER_WARNING_LAMP_IS_ON].strKey = "1";
            ReadNode[csReadNodeNo.LASER_WARNING_LAMP_IS_ON].priority = 0;

            ReadNode[csReadNodeNo.LASER_READY].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.LASER_READY";
            ReadNode[csReadNodeNo.LASER_READY].strDisplayNodeName = "LASER READY";
            ReadNode[csReadNodeNo.LASER_READY].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.LASER_READY].nExist = 1;
            ReadNode[csReadNodeNo.LASER_READY].strKey = "2";
            ReadNode[csReadNodeNo.LASER_READY].priority = 0;

            ReadNode[csReadNodeNo.LASER_IS_ON].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.LASER_IS_ON";
            ReadNode[csReadNodeNo.LASER_IS_ON].strDisplayNodeName = "LASER IS ON";
            ReadNode[csReadNodeNo.LASER_IS_ON].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.LASER_IS_ON].nExist = 1;
            ReadNode[csReadNodeNo.LASER_IS_ON].strKey = "3";
            ReadNode[csReadNodeNo.LASER_IS_ON].priority = 0;

            ReadNode[csReadNodeNo.LASER_ASSIGNED].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.LASER_ASSIGNED";
            ReadNode[csReadNodeNo.LASER_ASSIGNED].strDisplayNodeName = "LASER ASSIGNED";
            ReadNode[csReadNodeNo.LASER_ASSIGNED].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.LASER_ASSIGNED].nExist = 1;
            ReadNode[csReadNodeNo.LASER_ASSIGNED].strKey = "4";
            ReadNode[csReadNodeNo.LASER_ASSIGNED].priority = 0;

            ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.PILOT_LASER_IS_ON";
            ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].strDisplayNodeName = "PILOT LASER IS ON";
            ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].nExist = 1;
            ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].strKey = "5";
            ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].priority = 0;

            ReadNode[csReadNodeNo.PROG_COMPLETED].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.PROG_COMPLETED";
            ReadNode[csReadNodeNo.PROG_COMPLETED].strDisplayNodeName = "PROG COMPLETED";
            ReadNode[csReadNodeNo.PROG_COMPLETED].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.PROG_COMPLETED].nExist = 1;
            ReadNode[csReadNodeNo.PROG_COMPLETED].strKey = "6";
            ReadNode[csReadNodeNo.PROG_COMPLETED].priority = 0;

            ReadNode[csReadNodeNo.FAULT_LASER].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.FAULT_LASER";
            ReadNode[csReadNodeNo.FAULT_LASER].strDisplayNodeName = "FAULT LASER";
            ReadNode[csReadNodeNo.FAULT_LASER].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.FAULT_LASER].nExist = 1;
            ReadNode[csReadNodeNo.FAULT_LASER].strKey = "7";
            ReadNode[csReadNodeNo.FAULT_LASER].priority = 0;

            ReadNode[csReadNodeNo.PROG_ACTIVE].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.PROG_ACTIV";
            ReadNode[csReadNodeNo.PROG_ACTIVE].strDisplayNodeName = "PROG ACTIVE";
            ReadNode[csReadNodeNo.PROG_ACTIVE].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.PROG_ACTIVE].nExist = 1;
            ReadNode[csReadNodeNo.PROG_ACTIVE].strKey = "8";
            ReadNode[csReadNodeNo.PROG_ACTIVE].priority = 0;

            ReadNode[csReadNodeNo.PROG_CANCELLED].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.PROG_CANCELLED";
            ReadNode[csReadNodeNo.PROG_CANCELLED].strDisplayNodeName = "PROG CANCELLED";
            ReadNode[csReadNodeNo.PROG_CANCELLED].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.PROG_CANCELLED].nExist = 1;
            ReadNode[csReadNodeNo.PROG_CANCELLED].strKey = "9";
            ReadNode[csReadNodeNo.PROG_CANCELLED].priority = 0;

            ReadNode[csReadNodeNo.PROGRAM_NO].strNodeName = strHead + "ProgramNo";
            ReadNode[csReadNodeNo.PROGRAM_NO].strDisplayNodeName = "PROGRAM NO";
            ReadNode[csReadNodeNo.PROGRAM_NO].nNodeType = csNodeType.UINT16;
            ReadNode[csReadNodeNo.PROGRAM_NO].nExist = 1;
            ReadNode[csReadNodeNo.PROGRAM_NO].strKey = "10";
            ReadNode[csReadNodeNo.PROGRAM_NO].priority = 0;

            ReadNode[csReadNodeNo.PROGRAM_LINE_NO].strNodeName = strHead + "ProgramLineNo";
            ReadNode[csReadNodeNo.PROGRAM_LINE_NO].strDisplayNodeName = "PROGRAM LINE NO";
            ReadNode[csReadNodeNo.PROGRAM_LINE_NO].nNodeType = csNodeType.UINT16;
            ReadNode[csReadNodeNo.PROGRAM_LINE_NO].nExist = 1;
            ReadNode[csReadNodeNo.PROGRAM_LINE_NO].strKey = "11";
            ReadNode[csReadNodeNo.PROGRAM_LINE_NO].priority = 0;

            ReadNode[csReadNodeNo.MAINTENANCE].strNodeName = strHead + "Production.MPI-Slot04.Output.Word03.MAINTENANCE";
            ReadNode[csReadNodeNo.MAINTENANCE].strDisplayNodeName = "MAINTENANCE";
            ReadNode[csReadNodeNo.MAINTENANCE].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.MAINTENANCE].nExist = 1;
            ReadNode[csReadNodeNo.MAINTENANCE].strKey = "16";

            ReadNode[csReadNodeNo.MONITORING].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.MONITORING";
            ReadNode[csReadNodeNo.MONITORING].strDisplayNodeName = "MONITORING";
            ReadNode[csReadNodeNo.MONITORING].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.MONITORING].nExist = 1;
            ReadNode[csReadNodeNo.MONITORING].strKey = "17";
            ReadNode[csReadNodeNo.MONITORING].priority = 0;

            ReadNode[csReadNodeNo.POWER_LIMIT].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.POWER_LIMIT";
            ReadNode[csReadNodeNo.POWER_LIMIT].strDisplayNodeName = "POWER LIMIT";
            ReadNode[csReadNodeNo.POWER_LIMIT].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.POWER_LIMIT].nExist = 1;
            ReadNode[csReadNodeNo.POWER_LIMIT].strKey = "18";

            ReadNode[csReadNodeNo.SIK_OPEN].strNodeName = strHead + "Production.MPI-Slot04.Output.Word00.SIK_OPEN";
            ReadNode[csReadNodeNo.SIK_OPEN].strDisplayNodeName = "SIK OPEN";
            ReadNode[csReadNodeNo.SIK_OPEN].nNodeType = csNodeType.BOOL;
            ReadNode[csReadNodeNo.SIK_OPEN].nExist = 1;
            ReadNode[csReadNodeNo.SIK_OPEN].strKey = "21";

            ReadNode[csReadNodeNo.PULSE_POWER].strNodeName = strHead + "PulseData.PulsePower";
            ReadNode[csReadNodeNo.PULSE_POWER].strDisplayNodeName = "PULSE POWER";
            ReadNode[csReadNodeNo.PULSE_POWER].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.PULSE_POWER].nExist = 1;
            ReadNode[csReadNodeNo.PULSE_POWER].nDigit = 1000;
            ReadNode[csReadNodeNo.PULSE_POWER].strKey = "26";

            ReadNode[csReadNodeNo.PULSE_POWER_NOMINAL].strNodeName = strHead + "PulseData.PulsePowerNominal";
            ReadNode[csReadNodeNo.PULSE_POWER_NOMINAL].strDisplayNodeName = "PULSE POWER NOMINAL";
            ReadNode[csReadNodeNo.PULSE_POWER_NOMINAL].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.PULSE_POWER_NOMINAL].nExist = 1;
            ReadNode[csReadNodeNo.PULSE_POWER_NOMINAL].nDigit = 1000;
            ReadNode[csReadNodeNo.PULSE_POWER_NOMINAL].strKey = "27";

            ReadNode[csReadNodeNo.CW_POWER].strNodeName = strHead + "PulseData.CwPower";
            ReadNode[csReadNodeNo.CW_POWER].strDisplayNodeName = "CW POWER";
            ReadNode[csReadNodeNo.CW_POWER].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.CW_POWER].nExist = 1;
            ReadNode[csReadNodeNo.CW_POWER].strKey = "28";

            ReadNode[csReadNodeNo.POWER].strNodeName = strHead + "PulseData.Power";
            ReadNode[csReadNodeNo.POWER].strDisplayNodeName = "POWER";
            ReadNode[csReadNodeNo.POWER].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.POWER].nExist = 1;
            ReadNode[csReadNodeNo.POWER].strKey = "29";

            ReadNode[csReadNodeNo.ENERGEY].strNodeName = strHead + "PulseData.Energy";
            ReadNode[csReadNodeNo.ENERGEY].strDisplayNodeName = "ENERGY";
            ReadNode[csReadNodeNo.ENERGEY].nNodeType = csNodeType.UINT64;
            ReadNode[csReadNodeNo.ENERGEY].nExist = 1;
            ReadNode[csReadNodeNo.ENERGEY].strKey = "30";

            ReadNode[csReadNodeNo.FREQUENCY].strNodeName = strHead + "PulseData.Frequency";
            ReadNode[csReadNodeNo.FREQUENCY].strDisplayNodeName = "FREQUENCY";
            ReadNode[csReadNodeNo.FREQUENCY].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.FREQUENCY].nExist = 1;
            ReadNode[csReadNodeNo.FREQUENCY].strKey = "31";

            ReadNode[csReadNodeNo.FREQUENCY_NOMINAL].strNodeName = strHead + "PulseData.FrequencyNominal";
            ReadNode[csReadNodeNo.FREQUENCY_NOMINAL].strDisplayNodeName = "FREQUENCY NOMINAL";
            ReadNode[csReadNodeNo.FREQUENCY_NOMINAL].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.FREQUENCY_NOMINAL].nExist = 1;
            ReadNode[csReadNodeNo.FREQUENCY_NOMINAL].strKey = "32";

            ReadNode[csReadNodeNo.PULSE_DURATION].strNodeName = strHead + "PulseData.PulseDuration";
            ReadNode[csReadNodeNo.PULSE_DURATION].strDisplayNodeName = "PULSE DURATION";
            ReadNode[csReadNodeNo.PULSE_DURATION].nNodeType = csNodeType.UINT32;
            ReadNode[csReadNodeNo.PULSE_DURATION].nExist = 1;
            ReadNode[csReadNodeNo.PULSE_DURATION].strKey = "33";

            ReadNode[csReadNodeNo.PULSE_DURATION_NOMINAL].strNodeName = strHead + "PulseData.PulseDurationNominal";
            ReadNode[csReadNodeNo.PULSE_DURATION_NOMINAL].strDisplayNodeName = "PULSE DURATION NOMINAL";
            ReadNode[csReadNodeNo.PULSE_DURATION_NOMINAL].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.PULSE_DURATION_NOMINAL].nExist = 1;
            ReadNode[csReadNodeNo.PULSE_DURATION_NOMINAL].strKey = "34";

            ReadNode[csReadNodeNo.PULSE_NUMBER].strNodeName = strHead + "PulseData.PulseNumber";
            ReadNode[csReadNodeNo.PULSE_NUMBER].strDisplayNodeName = "PULSE NUMBER";
            ReadNode[csReadNodeNo.PULSE_NUMBER].nNodeType = csNodeType.UINT16;
            ReadNode[csReadNodeNo.PULSE_NUMBER].nExist = 1;
            ReadNode[csReadNodeNo.PULSE_NUMBER].strKey = "35";

            ReadNode[csReadNodeNo.PULSE_NUMBER_NOMINAL].strNodeName = strHead + "PulseData.PulseNumberNominal";
            ReadNode[csReadNodeNo.PULSE_NUMBER_NOMINAL].strDisplayNodeName = "PULSE NUMBER NOMINAL";
            ReadNode[csReadNodeNo.PULSE_NUMBER_NOMINAL].nNodeType = csNodeType.UINT16;
            ReadNode[csReadNodeNo.PULSE_NUMBER_NOMINAL].nExist = 1;
            ReadNode[csReadNodeNo.PULSE_NUMBER_NOMINAL].strKey = "36";

            ReadNode[csReadNodeNo.COOLING_DI_PRESSURE_DIFF].strNodeName = strHead + "Cooling.DIPressureDiff";
            ReadNode[csReadNodeNo.COOLING_DI_PRESSURE_DIFF].strDisplayNodeName = "DI PRESSURE DIFF";
            ReadNode[csReadNodeNo.COOLING_DI_PRESSURE_DIFF].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_DI_PRESSURE_DIFF].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_DI_PRESSURE_DIFF].strKey = "37";

            ReadNode[csReadNodeNo.COOLING_DI_RETURN_PRESSURE].strNodeName = strHead + "Cooling.DIReturnPressure";
            ReadNode[csReadNodeNo.COOLING_DI_RETURN_PRESSURE].strDisplayNodeName = "DI RETURN PRESSURE";
            ReadNode[csReadNodeNo.COOLING_DI_RETURN_PRESSURE].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_DI_RETURN_PRESSURE].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_DI_RETURN_PRESSURE].strKey = "38";

            //CODE.BY.YIS Laser Cool Parameter Log 추가
            strHead = "ns=2;s=[B0/01].";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_OUT_EXT].strNodeName = strHead + "Rd_CCB_PressureOut_Ext";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_OUT_EXT].strDisplayNodeName = "CCB PRESSURE OUT EXT ";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_OUT_EXT].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_PRESSURE_OUT_EXT].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_PRESSURE_OUT_EXT].strKey = "39";

            ReadNode[csReadNodeNo.COOLING_PRESSURE_IN_EXT].strNodeName = strHead + "Rd_CCB_PressureIn_Ext";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_IN_EXT].strDisplayNodeName = "CCB PRESSURE IN EXT ";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_IN_EXT].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_PRESSURE_IN_EXT].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_PRESSURE_IN_EXT].strKey = "40";

            ReadNode[csReadNodeNo.COOLING_TEMP_WATER_IN_EXT].strNodeName = strHead + "Rd_CCB_TempWaterIn_Ext";
            ReadNode[csReadNodeNo.COOLING_TEMP_WATER_IN_EXT].strDisplayNodeName = "CCB TEMP WATER IN EXT ";
            ReadNode[csReadNodeNo.COOLING_TEMP_WATER_IN_EXT].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_TEMP_WATER_IN_EXT].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_TEMP_WATER_IN_EXT].strKey = "41";

            ReadNode[csReadNodeNo.COOLING_PWM_X30_MV].strNodeName = strHead + "Rd_CCB_PWM_X30_MV";
            ReadNode[csReadNodeNo.COOLING_PWM_X30_MV].strDisplayNodeName = "CCB PWM X30 MV ";
            ReadNode[csReadNodeNo.COOLING_PWM_X30_MV].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_PWM_X30_MV].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_PWM_X30_MV].strKey = "42";

            ReadNode[csReadNodeNo.COOLING_TEMP_TANK_SET_TRACKING].strNodeName = strHead + "Rd_CCB_TempTank_Set_Tracking";
            ReadNode[csReadNodeNo.COOLING_TEMP_TANK_SET_TRACKING].strDisplayNodeName = "CCB TEMP TANK SET TRACKING ";
            ReadNode[csReadNodeNo.COOLING_TEMP_TANK_SET_TRACKING].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_TEMP_TANK_SET_TRACKING].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_TEMP_TANK_SET_TRACKING].strKey = "43";

            ReadNode[csReadNodeNo.COOLING_TEMP_COOLING_WATER].strNodeName = strHead + "Rd_CCB_TempCoolingWater";
            ReadNode[csReadNodeNo.COOLING_TEMP_COOLING_WATER].strDisplayNodeName = "CCB TEMP COOLING WATER ";
            ReadNode[csReadNodeNo.COOLING_TEMP_COOLING_WATER].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_TEMP_COOLING_WATER].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_TEMP_COOLING_WATER].strKey = "44";

            ReadNode[csReadNodeNo.COOLING_PRESSURE_PUMP].strNodeName = strHead + "Rd_CCB_PressurePump";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_PUMP].strDisplayNodeName = "CCG PRESSURE PUMP ";
            ReadNode[csReadNodeNo.COOLING_PRESSURE_PUMP].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_PRESSURE_PUMP].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_PRESSURE_PUMP].strKey = "45";

            ReadNode[csReadNodeNo.COOLING_FC_MAX_FREQUENCY].strNodeName = strHead + "Rd_CCB_FC_MaxFrequency";
            ReadNode[csReadNodeNo.COOLING_FC_MAX_FREQUENCY].strDisplayNodeName = "CCG FC MAX FREQUENCY ";
            ReadNode[csReadNodeNo.COOLING_FC_MAX_FREQUENCY].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_FC_MAX_FREQUENCY].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_FC_MAX_FREQUENCY].strKey = "46";

            //ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_CM_ACTUAL].strNodeName = strHead + "Rd_CCB_FC_Frequency_CM_actual";
            //ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_CM_ACTUAL].strDisplayNodeName = "CCG FC PREQUENCY CM ACTUAL ";
            ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_PUMP].strNodeName = strHead + "Rd_CCB_FC_FrequencyPump";
            ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_PUMP].strDisplayNodeName = "CCG FC PREQUENCY PUMP ";
            ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_PUMP].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_PUMP].nExist = 1;
            ReadNode[csReadNodeNo.COOLING_FC_FREQUENCY_PUMP].strKey = "47";

            strHead = "ns=2;s=[CE/01].";
            ReadNode[csReadNodeNo.COLLING_TEMP_X80].strNodeName = strHead + "Rd_ILD_Temp_X80";
            ReadNode[csReadNodeNo.COLLING_TEMP_X80].strDisplayNodeName = "CCG ILD TEMP X80";
            ReadNode[csReadNodeNo.COLLING_TEMP_X80].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COLLING_TEMP_X80].nExist = 1;
            ReadNode[csReadNodeNo.COLLING_TEMP_X80].strKey = "48";

            ReadNode[csReadNodeNo.COLLING_PRES_X90].strNodeName = strHead + "Rd_ILD_Pres_X90";
            ReadNode[csReadNodeNo.COLLING_PRES_X90].strDisplayNodeName = "CCG ILD TEMP X90";
            ReadNode[csReadNodeNo.COLLING_PRES_X90].nNodeType = csNodeType.DOUBLE;
            ReadNode[csReadNodeNo.COLLING_PRES_X90].nExist = 1;
            ReadNode[csReadNodeNo.COLLING_PRES_X90].strKey = "49";

            strHead = "ns=2;s=[DC/01].";
            ReadNode[csReadNodeNo.COLLING_SPEED_FAN].strNodeName = strHead + "Rd_CMD3_Speed_Fan1";
            ReadNode[csReadNodeNo.COLLING_SPEED_FAN].strDisplayNodeName = "CCG SPEED FAN";
            ReadNode[csReadNodeNo.COLLING_SPEED_FAN].nNodeType = csNodeType.UINT16;
            ReadNode[csReadNodeNo.COLLING_SPEED_FAN].nExist = 1;
            ReadNode[csReadNodeNo.COLLING_SPEED_FAN].strKey = "50";

            //----------        Write NODE
            strHead = "ns=2;s=";
            WriteNode[csWriteNodeNo.EXT_ACTIVATION].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.EXT_ACTIVATION";
            WriteNode[csWriteNodeNo.EXT_ACTIVATION].strDisplayNodeName = "EXT ACTIVATION";
            WriteNode[csWriteNodeNo.EXT_ACTIVATION].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.EXT_ACTIVATION].nExist = 1;
            WriteNode[csWriteNodeNo.EXT_ACTIVATION].strKey = "100";
            WriteNode[csWriteNodeNo.EXT_ACTIVATION].priority = 0;

            WriteNode[csWriteNodeNo.LASER_RESET].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.RESET";
            WriteNode[csWriteNodeNo.LASER_RESET].strDisplayNodeName = "LASER RESET";
            WriteNode[csWriteNodeNo.LASER_RESET].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.LASER_RESET].nExist = 1;
            WriteNode[csWriteNodeNo.LASER_RESET].strKey = "101";
            WriteNode[csWriteNodeNo.LASER_RESET].priority = 0;

            WriteNode[csWriteNodeNo.LASER_ON].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.LASER_ON";
            WriteNode[csWriteNodeNo.LASER_ON].strDisplayNodeName = "LASER ON";
            WriteNode[csWriteNodeNo.LASER_ON].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.LASER_ON].nExist = 1;
            WriteNode[csWriteNodeNo.LASER_ON].strKey = "102";
            WriteNode[csWriteNodeNo.LASER_ON].priority = 0;

            WriteNode[csWriteNodeNo.PROG_STOP].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.PROG_STOP";
            WriteNode[csWriteNodeNo.PROG_STOP].strDisplayNodeName = "PROG STOP";
            WriteNode[csWriteNodeNo.PROG_STOP].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.PROG_STOP].nExist = 1;
            WriteNode[csWriteNodeNo.PROG_STOP].strKey = "103";
            WriteNode[csWriteNodeNo.PROG_STOP].priority = 0;

            WriteNode[csWriteNodeNo.PSTART_DYN].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.PSTART_DYN";
            WriteNode[csWriteNodeNo.PSTART_DYN].strDisplayNodeName = "PSTART DYN";
            WriteNode[csWriteNodeNo.PSTART_DYN].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.PSTART_DYN].nExist = 1;
            WriteNode[csWriteNodeNo.PSTART_DYN].strKey = "104";
            WriteNode[csWriteNodeNo.PSTART_DYN].priority = 0;

            WriteNode[csWriteNodeNo.REQUEST_LASER].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.REQUEST_LASER";
            WriteNode[csWriteNodeNo.REQUEST_LASER].strDisplayNodeName = "REQUEST LASER";
            WriteNode[csWriteNodeNo.REQUEST_LASER].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.REQUEST_LASER].nExist = 1;
            WriteNode[csWriteNodeNo.REQUEST_LASER].strKey = "105";
            WriteNode[csWriteNodeNo.REQUEST_LASER].priority = 0;

            WriteNode[csWriteNodeNo.PSTART_STATICAL].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.PSTART_STATICAL";
            WriteNode[csWriteNodeNo.PSTART_STATICAL].strDisplayNodeName = "PSTART STATICAL";
            WriteNode[csWriteNodeNo.PSTART_STATICAL].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.PSTART_STATICAL].nExist = 1;
            WriteNode[csWriteNodeNo.PSTART_STATICAL].strKey = "106";

            WriteNode[csWriteNodeNo.INQUIRY_1].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.INQUIRY_1";
            WriteNode[csWriteNodeNo.INQUIRY_1].strDisplayNodeName = "INQUIRY 1";
            WriteNode[csWriteNodeNo.INQUIRY_1].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.INQUIRY_1].nExist = 1;
            WriteNode[csWriteNodeNo.INQUIRY_1].strKey = "107";

            WriteNode[csWriteNodeNo.INQUIRY_2].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.INQUIRY_2";
            WriteNode[csWriteNodeNo.INQUIRY_2].strDisplayNodeName = "INQUIRY 2";
            WriteNode[csWriteNodeNo.INQUIRY_2].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.INQUIRY_2].nExist = 1;
            WriteNode[csWriteNodeNo.INQUIRY_2].strKey = "108";

            WriteNode[csWriteNodeNo.PILOT_LASER_ON].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.PILOT_LASER_ON";
            WriteNode[csWriteNodeNo.PILOT_LASER_ON].strDisplayNodeName = "PILOT LASER ON";
            WriteNode[csWriteNodeNo.PILOT_LASER_ON].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.PILOT_LASER_ON].nExist = 1;
            WriteNode[csWriteNodeNo.PILOT_LASER_ON].strKey = "109";
            WriteNode[csWriteNodeNo.PILOT_LASER_ON].priority = 0;

            WriteNode[csWriteNodeNo.FAULT_EXT].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.FAULT_EXT";
            WriteNode[csWriteNodeNo.FAULT_EXT].strDisplayNodeName = "FAULT EXT";
            WriteNode[csWriteNodeNo.FAULT_EXT].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.FAULT_EXT].nExist = 1;
            WriteNode[csWriteNodeNo.FAULT_EXT].strKey = "110";
            WriteNode[csWriteNodeNo.FAULT_EXT].priority = 0;

            WriteNode[csWriteNodeNo.LOCK_OPERATING_PANEL].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word00.LOCK_OPERATING_PANEL";
            WriteNode[csWriteNodeNo.LOCK_OPERATING_PANEL].strDisplayNodeName = "LOCK OPERATING PANEL";
            WriteNode[csWriteNodeNo.LOCK_OPERATING_PANEL].nNodeType = csNodeType.BOOL;
            WriteNode[csWriteNodeNo.LOCK_OPERATING_PANEL].nExist = 1;
            WriteNode[csWriteNodeNo.LOCK_OPERATING_PANEL].strKey = "111";

            WriteNode[csWriteNodeNo.PROGRAM_NO].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word01.PROGRAM_No";
            WriteNode[csWriteNodeNo.PROGRAM_NO].strDisplayNodeName = "PROGRAM NO";
            WriteNode[csWriteNodeNo.PROGRAM_NO].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.PROGRAM_NO].nExist = 1;
            WriteNode[csWriteNodeNo.PROGRAM_NO].strKey = "112";
            WriteNode[csWriteNodeNo.PROGRAM_NO].priority = 0;

            WriteNode[csWriteNodeNo.IW03].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word03";
            WriteNode[csWriteNodeNo.IW03].strDisplayNodeName = "IW03";
            WriteNode[csWriteNodeNo.IW03].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.IW03].nExist = 1;
            WriteNode[csWriteNodeNo.IW03].strKey = "113";
            WriteNode[csWriteNodeNo.IW03].priority = 0;

            WriteNode[csWriteNodeNo.IW04].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word04";
            WriteNode[csWriteNodeNo.IW04].strDisplayNodeName = "IW04";
            WriteNode[csWriteNodeNo.IW04].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.IW04].nExist = 1;
            WriteNode[csWriteNodeNo.IW04].strKey = "114";
            WriteNode[csWriteNodeNo.IW04].priority = 0;

            WriteNode[csWriteNodeNo.IW05].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word05";
            WriteNode[csWriteNodeNo.IW05].strDisplayNodeName = "IW05";
            WriteNode[csWriteNodeNo.IW05].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.IW05].nExist = 1;
            WriteNode[csWriteNodeNo.IW05].strKey = "115";
            WriteNode[csWriteNodeNo.IW05].priority = 0;

            WriteNode[csWriteNodeNo.IW06].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word06";
            WriteNode[csWriteNodeNo.IW06].strDisplayNodeName = "IW06";
            WriteNode[csWriteNodeNo.IW06].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.IW06].nExist = 1;
            WriteNode[csWriteNodeNo.IW06].strKey = "116";
            WriteNode[csWriteNodeNo.IW06].priority = 0;

            WriteNode[csWriteNodeNo.IW07].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word07";
            WriteNode[csWriteNodeNo.IW07].strDisplayNodeName = "IW07";
            WriteNode[csWriteNodeNo.IW07].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.IW07].nExist = 1;
            WriteNode[csWriteNodeNo.IW07].strKey = "117";
            WriteNode[csWriteNodeNo.IW07].priority = 0;

            WriteNode[csWriteNodeNo.IW08].strNodeName = strHead + "Activation.MPI-Slot04.Input.Word08";
            WriteNode[csWriteNodeNo.IW08].strDisplayNodeName = "IW08";
            WriteNode[csWriteNodeNo.IW08].nNodeType = csNodeType.UINT16;
            WriteNode[csWriteNodeNo.IW08].nExist = 1;
            WriteNode[csWriteNodeNo.IW08].strKey = "118";
            WriteNode[csWriteNodeNo.IW08].priority = 0;

            #region 읽어올 Node ID를 배열에 미리 넣어둔다(ReadNodeData 함수에서 사용)
            if (isCallBack) {
                readNodeIdList = null;
                writeNodeIdList = null;
            } else {
                readNodeIdList = new List<NodeId>();

                for (int nTarget = 0; nTarget < 100; nTarget++) {
                    if (ReadNode[nTarget].nExist != 1) continue;
                    else if (ReadNode[nTarget].IsCallBack == 1) continue;

                    NodeId nodeId = new NodeId(ReadNode[nTarget].strNodeName);

                    readNodeIdList.Add(nodeId);
                }

                writeNodeIdList = new List<NodeId>();

                for (int nTarget = 0; nTarget < 100; nTarget++) {
                    if (WriteNode[nTarget].nExist != 1) continue;
                    else if (WriteNode[nTarget].IsCallBack == 1) continue;

                    NodeId nodeId = new NodeId(WriteNode[nTarget].strNodeName);

                    writeNodeIdList.Add(nodeId);
                }
            }
            #endregion
        }

        public int Open(LaserConfig Config)
        {
            if (ConnectServer() == 1) {
                m_threadTrueDiskSeq = new Thread(new ThreadStart(TrueDiskThread_Seq));
                m_threadTrueDiskSeq.Start();
                return 1;
            } else return 0;
        }
        public void DisConnect()
        {
            try {
                if (IsConnect == true) {
                    SetData(csWriteNodeNo.PROG_STOP, 1);
                    Thread.Sleep(500);
                    SetData(csWriteNodeNo.PROG_STOP, 0);
                    SetData(csWriteNodeNo.PSTART_STATICAL, 0);
                    SetData(csWriteNodeNo.PSTART_DYN, 0);
                    SetData(csWriteNodeNo.REQUEST_LASER, 0);
                    SetData(csWriteNodeNo.LASER_ON, 0);
                    SetData(csWriteNodeNo.EXT_ACTIVATION, 0);
                }

                if (m_threadTrueDiskSeq != null) {
                    m_threadTrueDiskSeq.Join(500);
                    m_threadTrueDiskSeq.Abort();
                }

                try {
                    if (IsConnect) {
                        _session.RemoveSubscription(_subscription);

                        StatusCode result = _session.Close();

                        IsConnect = false;
                    }
                } catch (Exception ex) {
                    throw ex;
                }
            } catch {

            }

            IsConnect = false;

            return;
        }
        public bool GetConnected()
        {
            return IsConnect;
        }
        public int SetData(int nTarget, int value)
        {
            if (!IsConnect) return 0;

            try {
                NodeId nodeId = new NodeId(WriteNode[nTarget].strNodeName);

                WriteNodeValue(nodeId, (object)value);

                return 1;
            } catch (Exception ex) {
                throw ex;
            }
        }
        public string GetData(int nTarget)
        {
            string strRet = "Not Exist";
            int nArrayNo;

            try {
                if (nTarget >= 0 && nTarget < 100) {
                    lock (readNodeLock) {
                        nArrayNo = nTarget;

                        if (ReadNode[nArrayNo].nExist != 1) return strRet;

                        switch (ReadNode[nArrayNo].nNodeType) {
                            case csNodeType.INT:
                                strRet = string.Format("{0:D0}", ReadNode[nArrayNo].nRet);
                                break;
                            case csNodeType.DOUBLE:
                                strRet = string.Format("{0:F2}", ReadNode[nArrayNo].dRet);
                                break;
                            case csNodeType.STRING:
                                strRet = ReadNode[nArrayNo].strRet;
                                break;
                            case csNodeType.UINT16:
                                strRet = string.Format("{0:D0}", (int)ReadNode[nArrayNo].n16Ret);
                                break;
                            case csNodeType.UINT32:
                                strRet = string.Format("{0:D0}", (int)ReadNode[nArrayNo].n32Ret);
                                break;
                            case csNodeType.UINT64:
                                strRet = string.Format("{0:D0}", (int)ReadNode[nArrayNo].n64Ret);
                                break;
                            case csNodeType.BOOL:
                                strRet = ReadNode[nArrayNo].nRet == 1 ? "1" : "0";
                                break;
                            case csNodeType.BYTE:
                                strRet = string.Format("{0:D0}", (int)ReadNode[nArrayNo].nRet);
                                break;
                            default:
                                break;
                        }
                    }
                } else {
                    lock (writeNodeLock) {
                        nArrayNo = nTarget - 100;

                        if (WriteNode[nArrayNo].nExist != 1) return strRet;

                        switch (WriteNode[nArrayNo].nNodeType) {
                            case csNodeType.INT:
                                strRet = string.Format("{0:D0}", WriteNode[nArrayNo].nRet);
                                break;
                            case csNodeType.DOUBLE:
                                strRet = string.Format("{0:F2}", WriteNode[nArrayNo].dRet);
                                break;
                            case csNodeType.STRING:
                                strRet = WriteNode[nArrayNo].strRet;
                                break;
                            case csNodeType.UINT16:
                                strRet = string.Format("{0:D0}", (int)WriteNode[nArrayNo].n16Ret);
                                break;
                            case csNodeType.UINT32:
                                strRet = string.Format("{0:D0}", (int)WriteNode[nArrayNo].n32Ret);
                                break;
                            case csNodeType.UINT64:
                                strRet = string.Format("{0:D0}", (int)WriteNode[nArrayNo].n64Ret);
                                break;
                            case csNodeType.BOOL:
                                strRet = WriteNode[nArrayNo].nRet == 1 ? "1" : "0";
                                break;
                            case csNodeType.BYTE:
                                strRet = string.Format("{0:D0}", (int)WriteNode[nArrayNo].nRet);
                                break;
                            default:
                                break;
                        }
                    }
                }
            } catch (Exception ex) {
                throw ex;
            }

            return strRet;
        }

        public int LaserOn()
        {
            SetLaserOn(true);
            return 1;
        }

        public int LaserOff()
        {

            SetLaserOn(false);

            return 1;
        }
        public int PilotLaserOn()
        {
            // thread 가 있는것 같은데, node를 바로 write 하면 되는게 맞는가?
            return SetData(csWriteNodeNo.PILOT_LASER_ON, 1);
        }

        public int PilotLaserOff()
        {
            // thread 가 있는것 같은데, node를 바로 write 하면 되는게 맞는가?
            return SetData(csWriteNodeNo.PILOT_LASER_ON, 0);
        }

        public bool GetInitCommunication()
        {
            // 업데이트 예정
            return false;
        }
        public bool GetEmissionStatus()
        {
            // 업데이트 예정
            return false;
        }
        public bool GetWariningStatus()
        {
            // 업데이트 예정
            return false;
        }
        // MAINS_STATUS, ERROR_STATUS 는 위에 있음
        public bool GetPilotLaserStatus()
        {
            // 업데이트 예정
            return false;
        }
        public string GetControlMode()
        {
            // 업데이트 예정
            return "";
        }
        public string GetPowerCenter()
        {
            // 업데이트 예정
            return "";
        }
        public string GetPowerRing()
        {
            // 업데이트 예정
            return "";
        }
        #region Set 명령 나간 bit 를 모니터링
        public bool GetStartLaserSetBitStatus()
        {

            // Laser Start 명령
            // 업데이트 예정
            return false;
        }
        public bool GetLaserStartSetBitStatus()
        {
            // Laser On 명령. Laser Emission Ready 를 위한 bit
            // 업데이트 예정
            return false;
        }
        public bool GetPilotLaserSetBitStatus()
        {
            // Pilot Laser On 명령.
            // 업데이트 예정
            return false;
        }
        public bool GetLaserResetSetBitStatus()
        {
            // Laser Reset 명령.
            // 업데이트 예정
            return false;
        }
        public bool GetControlModeSetStatus()
        {
            //  Control mode Local(false) Remote(true)
            // 업데이트 예정
            return false;
        }
        #endregion

        public int ConnectServer()      //  Connect OPC UA Server, Resist Read Nodes.
        {
            if (_session != null && _session.Connected) return 2;

            #region Opc Ua 새로운 API 사용
            try {
                ApplicationConfiguration config = new Opc.Ua.ApplicationConfiguration() {
                    ApplicationName = "OPCClientTest",
                    ApplicationType = ApplicationType.Client,
                    SecurityConfiguration = new SecurityConfiguration {
                        ApplicationCertificate = new CertificateIdentifier(),
                        AutoAcceptUntrustedCertificates = true,
                    },
                    ClientConfiguration = new ClientConfiguration { DefaultSessionTimeout = 60000 },
                };

                config.Validate(ApplicationType.Client);

                if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates) {
                    config.CertificateValidator.CertificateValidation += (s, ex) => {
                        ex.Accept = (ex.Error.StatusCode == StatusCodes.BadCertificateUntrusted);
                    };
                }

                // 연결 Url 설정
                string endpointUrl = strServerAddress;

                // 연결 시작(Session 연결)
                var userIdentity = new UserIdentity(strID, strPW);
                //var selectedEndPoint = CoreClientUtils.SelectEndpoint(endpointUrl, useSecurity: false);
                //var endconf = new ConfiguredEndpoint(null, selectedEndPoint, EndpointConfiguration.Create(config));   // version 1
                var endconf = new ConfiguredEndpoint(null, new EndpointDescription(endpointUrl));                       // version 2

                _session = Session.Create(config, endconf, true, "session", 60000, userIdentity, null).GetAwaiter().GetResult();

                IsConnect = _session.Connected;
            } catch (Exception ex) {
                IsConnect = false;

                Debug.WriteLine("TruDisk.ConnectServer() - Exception : " + ex.Message);
            }
            #endregion

            if (IsConnect == false) return 0;

            System.Threading.Thread.Sleep(500);

            RegistReadNodes();
            return 1;
        }

        public int RegistReadNodes()
        {
            try {
                if (_session == null || !_session.Connected) return 0;

                if (_subscription != null) {
                    _session.RemoveSubscription(_subscription);
                    _subscription = null;
                }

                // 모니터링 설정
                _subscription = new Subscription(_session.DefaultSubscription) {
                    PublishingEnabled = true,
                    PublishingInterval = 50,  // TruDisk 2021 최소값은 50ms
                };

                // 모니터링 할 Item List
                var listRead = new List<MonitoredItem> { };
                var listWrite = new List<MonitoredItem> { };

                // List 추가
                for (int i = 0; i < 100; i++) {
                    if (ReadNode[i].nExist == 0) continue;
                    if (ReadNode[i].IsCallBack != 1) continue;

                    listRead.Add(new MonitoredItem() {
                        DisplayName = ReadNode[i].strDisplayNodeName,
                        StartNodeId = ReadNode[i].strNodeName,
                        // 단위는 ms, 100ms씩 증가, 0은 Server에서 가능한 가장 빠른 Interval(100ms)로 Sampling
                        SamplingInterval = ReadNode[i].priority == 0 ? 100 : 1000,
                    });
                }

                for (int i = 0; i < 100; i++) {
                    if (WriteNode[i].nExist == 0) continue;
                    if (WriteNode[i].IsCallBack != 1) continue;

                    listWrite.Add(new MonitoredItem() {
                        DisplayName = WriteNode[i].strDisplayNodeName,
                        StartNodeId = WriteNode[i].strNodeName,
                        // 단위는 ms, 100ms씩 증가, 0은 Server에서 가능한 가장 빠른 Interval(100ms)로 Sampling
                        SamplingInterval = WriteNode[i].priority == 0 ? 100 : 1000,
                    });
                }

                // 각각의 Item에 Event 추가
                listRead.ForEach(i => i.Notification += new MonitoredItemNotificationEventHandler(OnNotificationRead));
                listWrite.ForEach(i => i.Notification += new MonitoredItemNotificationEventHandler(OnNotificationWrite));

                // Subscription에 List 추가
                _subscription.AddItems(listRead);
                _subscription.AddItems(listWrite);

                // Session에 Subscription 추가
                _session.AddSubscription(_subscription);

                // Subscription 생성
                _subscription.Create();
            } catch (Exception ex) {
                throw ex;
            }

            return 1;
        }

        private Variant WriteNodeValue(NodeId nodeId, object value)
        {
            try {
                // cast the value to a string.
                //object value = TypeInfo.Cast(ValueTB.Text, TypeInfo.Scalars.String, m_sourceType.BuiltInType);

                // build list of attributes to read.
                WriteValueCollection nodesToWrite = new WriteValueCollection();

                WriteValue nodeToWrite = new WriteValue();
                nodeToWrite.NodeId = nodeId;
                nodeToWrite.AttributeId = Attributes.Value;

                // using the WrappedValue instead of the Value property because we know the TypeInfo.
                // this makes the assignment more efficient by avoiding reflection to determine type.
                //nodeToWrite.Value.WrappedValue = new Variant(value, m_sourceType);
                nodeToWrite.Value.WrappedValue = new Variant(value);

                nodesToWrite.Add(nodeToWrite);

                // override the diagnostic masks (other parameters are set to defaults).
                RequestHeader requestHeader = new RequestHeader();
                requestHeader.ReturnDiagnostics = (uint)DiagnosticsMasks.All;

                // read the attributes.
                StatusCodeCollection results = null;
                DiagnosticInfoCollection diagnosticInfos = null;

                ResponseHeader responseHeader = _session.Write(requestHeader, nodesToWrite, out results, out diagnosticInfos);

                ClientBase.ValidateResponse(results, nodesToWrite);
                ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToWrite);

                // check status.
                if (StatusCode.IsBad(results[0])) {
                    // embed the diagnostic information in a exception.
                    throw ServiceResultException.Create(results[0], 0, diagnosticInfos, responseHeader.StringTable);
                }

                // return valid value.
                return nodeToWrite.Value.WrappedValue;
            } catch (Exception ex) {
                throw ex;
            }
        }
        private void OnNotificationRead(MonitoredItem item, MonitoredItemNotificationEventArgs e)
        {
            try {
                MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;

                foreach (var value in item.DequeueValues()) {
                    // 상태가 정상일 경우
                    if (StatusCode.IsGood(value.StatusCode)) {
                        lock (readNodeLock) {
                            int nArrayNo = -1;

                            for (int i = 0; i < 100; i++) {
                                if (ReadNode[i].nExist == 1 && ReadNode[i].strDisplayNodeName == item.DisplayName) {
                                    nArrayNo = i;
                                    break;
                                }
                            }

                            if (0 <= nArrayNo && nArrayNo < 100) {
                                string strReturnData = value.Value.ToString();

                                switch (ReadNode[nArrayNo].nNodeType) {
                                    case csNodeType.INT:
                                        ReadNode[nArrayNo].nRet = int.Parse(strReturnData) * ReadNode[nArrayNo].nDigit;
                                        break;
                                    case csNodeType.DOUBLE:
                                        ReadNode[nArrayNo].dRet = (double.Parse(strReturnData) * ReadNode[nArrayNo].nDigit);
                                        break;
                                    case csNodeType.STRING:
                                        ReadNode[nArrayNo].strRet = strReturnData;
                                        break;
                                    case csNodeType.UINT16:
                                        ReadNode[nArrayNo].n16Ret = (ushort)(int.Parse(strReturnData) * ReadNode[nArrayNo].nDigit);
                                        break;
                                    case csNodeType.UINT32:
                                        ReadNode[nArrayNo].n32Ret = (uint)(uint.Parse(strReturnData) * ReadNode[nArrayNo].nDigit);
                                        break;
                                    case csNodeType.UINT64:
                                        ReadNode[nArrayNo].n64Ret = ulong.Parse(strReturnData) * (ulong)ReadNode[nArrayNo].nDigit;
                                        break;
                                    case csNodeType.BOOL:
                                        if (strReturnData == "True") ReadNode[nArrayNo].nRet = 1;
                                        else ReadNode[nArrayNo].nRet = 0;
                                        break;
                                    case csNodeType.BYTE:
                                        ReadNode[nArrayNo].nRet = byte.Parse(strReturnData) * ReadNode[nArrayNo].nDigit;
                                        break;
                                    default:
                                        break;
                                }
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                throw ex;
            }
        }

        private void OnNotificationWrite(MonitoredItem item, MonitoredItemNotificationEventArgs e)
        {
            try {
                MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;

                foreach (var value in item.DequeueValues()) {
                    // 상태가 정상일 경우
                    if (StatusCode.IsGood(value.StatusCode)) {
                        lock (writeNodeLock) {
                            int nArrayNo = -1;

                            for (int i = 0; i < 100; i++) {
                                if (WriteNode[i].nExist == 1 && WriteNode[i].strDisplayNodeName == item.DisplayName) {
                                    nArrayNo = i;
                                    break;
                                }
                            }

                            if (0 <= nArrayNo && nArrayNo < 100) {
                                string strReturnData = value.Value.ToString();

                                switch (WriteNode[nArrayNo].nNodeType) {
                                    case csNodeType.INT:
                                        WriteNode[nArrayNo].nRet = int.Parse(strReturnData) * WriteNode[nArrayNo].nDigit;
                                        break;
                                    case csNodeType.DOUBLE:
                                        WriteNode[nArrayNo].dRet = (double.Parse(strReturnData) * WriteNode[nArrayNo].nDigit);
                                        break;
                                    case csNodeType.STRING:
                                        WriteNode[nArrayNo].strRet = strReturnData;
                                        break;
                                    case csNodeType.UINT16:
                                        WriteNode[nArrayNo].n16Ret = (ushort)(int.Parse(strReturnData) * ReadNode[nArrayNo].nDigit);
                                        break;
                                    case csNodeType.UINT32:
                                        WriteNode[nArrayNo].n32Ret = (uint)(uint.Parse(strReturnData) * ReadNode[nArrayNo].nDigit);
                                        break;
                                    case csNodeType.UINT64:
                                        WriteNode[nArrayNo].n64Ret = ulong.Parse(strReturnData) * (ulong)ReadNode[nArrayNo].nDigit;
                                        break;
                                    case csNodeType.BOOL:
                                        if (strReturnData == "True") WriteNode[nArrayNo].nRet = 1;
                                        else WriteNode[nArrayNo].nRet = 0;
                                        break;
                                    case csNodeType.BYTE:
                                        WriteNode[nArrayNo].nRet = byte.Parse(strReturnData) * WriteNode[nArrayNo].nDigit;
                                        break;
                                    default:
                                        break;
                                }
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                throw ex;
            }
        }
        public void TrueDiskThread_Seq()
        {
            int timeOut = 10;
            DateTime startTime = DateTime.Now;

            while (true) {
                Thread.Sleep(20);

                try {
                    if (nSequence == eSeqStep.SEQ_NONE) {
                        if (ReadNode[csReadNodeNo.FAULT_LASER].nRet == 1 || ReadNode[csReadNodeNo.LIGHTPATH_BLOCKED].nRet == 1) {
                            nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                        }
                    }

                    switch (nSequence) {
                        case eSeqStep.SEQ_NONE:
                            break;

                        #region Laser On 시퀀스
                        case eSeqStep.SEQ_LASER_ON_START:
                            nLaserStatus = eLaserStatus.STATUS_LASER_ON_STEP;
                            SetData(csWriteNodeNo.EXT_ACTIVATION, 1);
                            startTime = DateTime.Now;

                            nSequence = eSeqStep.SEQ_LASER_ON_EXT_ACTIVE_CHK;
                            break;

                        case eSeqStep.SEQ_LASER_ON_EXT_ACTIVE_CHK:
                            if (ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].nRet == 1) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.PROGRAM_NO, 0);
                                SetData(csWriteNodeNo.PILOT_LASER_ON, 0);
                                SetData(csWriteNodeNo.LASER_RESET, 1);
                                nSequence = eSeqStep.SEQ_LASER_RESET_ON_CHK;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_RESET_ON_CHK:
                            if (WriteNode[csWriteNodeNo.LASER_RESET].nRet == 1) {
                                startTime = DateTime.Now;
                                nSequence = eSeqStep.SEQ_LASER_RESET_ON_DELAY;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_RESET_ON_DELAY:
                            if (ReadNode[csReadNodeNo.FAULT_LASER].nRet == 0 || 0.5 < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.LASER_RESET, 0);
                                nSequence = eSeqStep.SEQ_LASER_RESET_OFF_CHK;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_RESET_OFF_CHK:
                            if (WriteNode[csWriteNodeNo.LASER_RESET].nRet == 0) {
                                startTime = DateTime.Now;

                                SetData(csWriteNodeNo.LASER_ON, 1);
                                nSequence = eSeqStep.SEQ_LASER_ON_LASER_ON_CHK;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_ON_LASER_ON_CHK:
                            if (ReadNode[csReadNodeNo.LASER_IS_ON].nRet == 1) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.REQUEST_LASER, 1);
                                nSequence = eSeqStep.SEQ_LASER_ON_READY_CHK;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_ON_READY_CHK:
                            if (ReadNode[csReadNodeNo.LASER_READY].nRet == 1) {
                                if (AutoProgramStart) {
                                    startTime = DateTime.Now;
                                    SetData(csWriteNodeNo.PSTART_DYN, 1);
                                    nSequence = eSeqStep.SEQ_LASER_ON_DYNAMIC_ON_CHK;
                                } else {
                                    nLaserStatus = eLaserStatus.STATUS_LASER_READY;
                                    nSequence = eSeqStep.SEQ_NONE;
                                }
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_ON_DYNAMIC_ON_CHK:
                            if (WriteNode[csWriteNodeNo.PSTART_DYN].nRet == 1) {
                                SetData(csWriteNodeNo.PSTART_DYN, 0);
                                startTime = DateTime.Now;
                                nSequence = eSeqStep.SEQ_LASER_ON_PROG_ACTIVE_CHK;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_ON_PROG_ACTIVE_CHK:
                            if (ReadNode[csReadNodeNo.PROG_ACTIVE].nRet == 1) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_READY;
                                nSequence = eSeqStep.SEQ_NONE;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;
                        #endregion Laser On 시퀀스

                        #region Laser Off 시퀀스
                        case eSeqStep.SEQ_LASER_OFF_START:
                            nLaserStatus = eLaserStatus.STATUS_LASER_OFF_STEP;
                            SetData(csWriteNodeNo.PROG_STOP, 1);
                            SetData(csWriteNodeNo.PILOT_LASER_ON, 0);
                            startTime = DateTime.Now;

                            nSequence = eSeqStep.SEQ_LASER_OFF_PROG_STOP_ON_CHK;
                            break;

                        case eSeqStep.SEQ_LASER_OFF_PROG_STOP_ON_CHK:
                            if (WriteNode[csWriteNodeNo.PROG_STOP].nRet == 1) {
                                startTime = DateTime.Now;
                                nSequence = eSeqStep.SEQ_LASER_OFF_PROG_STOP_ON_DELAY;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_OFF_PROG_STOP_ON_DELAY:
                            if (ReadNode[csReadNodeNo.PROG_ACTIVE].nRet == 0 || 0.5 < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.PROG_STOP, 0);
                                nSequence = eSeqStep.SEQ_LASER_OFF_PROG_STOP_OFF_CHK;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_OFF_PROG_STOP_OFF_CHK:
                            if (WriteNode[csWriteNodeNo.PROG_STOP].nRet == 0) {
                                SetData(csWriteNodeNo.REQUEST_LASER, 0);
                                SetData(csWriteNodeNo.LASER_ON, 0);
                                SetData(csWriteNodeNo.EXT_ACTIVATION, 0);

                                nSequence = eSeqStep.SEQ_NONE;
                            } else if (timeOut < DateTime.Now.Subtract(startTime).TotalSeconds) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;
                        #endregion Laser Off 시퀀스

                        #region Pilot Laser On 시퀀스
                        case eSeqStep.SEQ_LASER_PILOT_LASER_ON_START:
                            nLaserStatus = eLaserStatus.STATUS_LASER_ON_STEP;
                            SetData(csWriteNodeNo.EXT_ACTIVATION, 1);
                            SetData(csWriteNodeNo.LASER_ON, 0);
                            SetData(csWriteNodeNo.PROGRAM_NO, 1);   // Laser Program 1번 광경로가 Absorber로 되어 있어야 함
                            startTime = DateTime.Now;

                            nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_ON_EXT_ACTIVE_CHK;
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_ON_EXT_ACTIVE_CHK:
                            if (ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].nRet == 1) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.LASER_RESET, 1);
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_ON_RESET_ON_CHK;
                            } else if (DateTime.Now.Subtract(startTime).TotalMilliseconds > (timeOut * 1000)) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_ON_RESET_ON_CHK:
                            if (WriteNode[csWriteNodeNo.LASER_RESET].nRet == 1) {
                                startTime = DateTime.Now;
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_ON_RESET_ON_DELAY;
                            } else if (DateTime.Now.Subtract(startTime).TotalMilliseconds > (timeOut * 1000 * 2)) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_ON_RESET_ON_DELAY:
                            if (DateTime.Now.Subtract(startTime).TotalMilliseconds > 500) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.LASER_RESET, 0);
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_ON_RESET_OFF_CHK;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_ON_RESET_OFF_CHK:
                            if (WriteNode[csWriteNodeNo.LASER_RESET].nRet == 0) {
                                startTime = DateTime.Now;
                                SetData(csWriteNodeNo.REQUEST_LASER, 1);
                                SetData(csWriteNodeNo.PILOT_LASER_ON, 1);
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_ON_PILOT_LASER_ON_CHK;
                            } else if (DateTime.Now.Subtract(startTime).TotalMilliseconds > (timeOut * 1000 * 2)) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_ON_PILOT_LASER_ON_CHK:
                            if (ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].nRet == 1) {
                                nLaserStatus = eLaserStatus.STATUS_NONE;
                                nSequence = eSeqStep.SEQ_NONE;
                            } else if (DateTime.Now.Subtract(startTime).TotalMilliseconds > (timeOut * 1000)) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;
                        #endregion Pilot Laser On 시퀀스

                        #region Pilot Laser Off 시퀀스
                        case eSeqStep.SEQ_LASER_PILOT_LASER_OFF_START:
                            nLaserStatus = eLaserStatus.STATUS_LASER_ON_STEP;
                            SetData(csWriteNodeNo.LASER_ON, 0);
                            SetData(csWriteNodeNo.PROGRAM_NO, 0);
                            SetData(csWriteNodeNo.REQUEST_LASER, 0);
                            SetData(csWriteNodeNo.PILOT_LASER_ON, 0);

                            startTime = DateTime.Now;

                            nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_OFF_CHK;
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_OFF_CHK:
                            if (ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].nRet == 0) {
                                SetData(csWriteNodeNo.REQUEST_LASER, 1);

                                startTime = DateTime.Now;
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_ON_CHK;
                            } else if (DateTime.Now.Subtract(startTime).TotalMilliseconds > (timeOut * 1000)) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_ON_CHK:
                            if (WriteNode[csWriteNodeNo.REQUEST_LASER].nRet == 1) {
                                startTime = DateTime.Now;
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_DELAY;
                            } else if (DateTime.Now.Subtract(startTime).TotalMilliseconds > (timeOut * 1000)) {
                                nLaserStatus = eLaserStatus.STATUS_LASER_ERROR;
                                nSequence = eSeqStep.SEQ_NONE;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_DELAY:
                            if (DateTime.Now.Subtract(startTime).TotalMilliseconds > 500) {
                                SetData(csWriteNodeNo.REQUEST_LASER, 0);
                                nSequence = eSeqStep.SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_OFF_CHK;
                            }
                            break;

                        case eSeqStep.SEQ_LASER_PILOT_LASER_OFF_REQUEST_LASER_OFF_CHK:
                            SetData(csWriteNodeNo.EXT_ACTIVATION, 0);
                            nSequence = eSeqStep.SEQ_NONE;
                            break;
                        #endregion Pilot Laser Off 시퀀스

                        default:
                            break;
                    }
                } catch {
                }
            }
        }

        public DataValue ReadNodeValue(NodeId nodeId)
        {
            try {
                ReadValueIdCollection itemsToRead = new ReadValueIdCollection();

                ReadValueId itemToRead = new ReadValueId() {
                    NodeId = nodeId,
                    AttributeId = Attributes.Value,
                };

                itemsToRead.Add(itemToRead);

                // read from server.
                DataValueCollection values = null;
                DiagnosticInfoCollection diagnosticInfos = null;

                ResponseHeader responseHeader = _session.Read(null, 0, TimestampsToReturn.Both, itemsToRead, out values, out diagnosticInfos);

                ClientBase.ValidateResponse(values, itemsToRead);
                ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToRead);

                if (StatusCode.IsBad(values[0].StatusCode)) {
                    ServiceResult result = ClientBase.GetResult(values[0].StatusCode, 0, diagnosticInfos, responseHeader);
                    throw new ServiceResultException(result);
                }

                return values[0];
            } catch (Exception ex) {
                throw ex;
            }
        }

        public List<DataValue> ReadNodeListValue(List<NodeId> nodeIdList)
        {
            try {
                ReadValueIdCollection itemsToRead = new ReadValueIdCollection();

                foreach (NodeId id in nodeIdList) {
                    ReadValueId itemToRead = new ReadValueId() {
                        NodeId = id,
                        AttributeId = Attributes.Value,
                    };

                    itemsToRead.Add(itemToRead);
                }

                // read from server.
                DataValueCollection values = null;
                DiagnosticInfoCollection diagnosticInfos = null;

                ResponseHeader responseHeader = _session.Read(null, 0, TimestampsToReturn.Both, itemsToRead, out values, out diagnosticInfos);

                ClientBase.ValidateResponse(values, itemsToRead);
                ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToRead);

                foreach (DataValue value in values) {
                    if (StatusCode.IsBad(value.StatusCode)) {
                        ServiceResult result = ClientBase.GetResult(value.StatusCode, 0, diagnosticInfos, responseHeader);
                        throw new ServiceResultException(result);
                    }
                }

                return values;
            } catch (Exception ex) {
                throw ex;
            }
        }

        #region Read/Write Node 호출 함수
        public bool GetLaserEmissionEnable()
        {
            if (AutoProgramStart) {
                return ReadNode[csReadNodeNo.PROG_ACTIVE].nRet == 1 ? true : false;
            } else {
                return ReadNode[csReadNodeNo.LASER_READY].nRet == 1 ? true : false;
            }
        }

        public bool GetPilotLaserOn()
        {
            return ReadNode[csReadNodeNo.PILOT_LASER_IS_ON].nRet == 1 ? true : false;
        }

        public bool GetLaserError()
        {
            int ret = 0;

            ret += (ReadNode[csReadNodeNo.FAULT_LASER].nRet == 1 ? 1 : 0);
            ret += ReadNode[csReadNodeNo.SIK_OPEN].nRet == 1 ? 2 : 0;

            return ret == 0 ? false : true;
        }

        public bool GetExternalActivation()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.EXT_ACTIVATION_ACTIVE].nRet == 1 ? true : false;
            }
        }

        public bool GetLaserIsOn()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.LASER_IS_ON].nRet == 1 ? true : false;
            }
        }

        public bool GetLaserAssigned()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.LASER_ASSIGNED].nRet == 1 ? true : false;
            }
        }

        public bool GetLaserReady()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.LASER_READY].nRet == 1 ? true : false;
            }
        }

        public bool GetProgramActive()
        {
            lock (readNodeLock) {
                //return ReadNode[csReadNodeNo.PROG_ACTIVE].nRet == 1 ? true : false;

                NodeId id = new NodeId(ReadNode[csReadNodeNo.PROG_ACTIVE].strNodeName);

                return Convert.ToBoolean(ReadNodeValue(id).Value) ? true : false;
            }
        }

        public bool GetProgramCompleted()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.PROG_COMPLETED].nRet == 1 ? true : false;
            }
        }

        public bool GetProgramCancelled()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.PROG_CANCELLED].nRet == 1 ? true : false;
            }
        }

        public int GetProgramNo()
        {
            lock (readNodeLock) {
                return ReadNode[csReadNodeNo.PROGRAM_NO].n16Ret;
            }
        }

        public int GetProgramLineNo()
        {
            lock (readNodeLock) {
                //return ReadNode[csReadNodeNo.PROGRAM_LINE_NO].n16Ret;

                NodeId id = new NodeId(ReadNode[csReadNodeNo.PROGRAM_LINE_NO].strNodeName);

                return Convert.ToInt32(ReadNodeValue(id).Value);
            }
        }

        public int SetExternalActivation(bool bOn)
        {
            return SetData(csWriteNodeNo.EXT_ACTIVATION, bOn ? 1 : 0);
        }

        public int SetLaserReset(bool bOn)
        {
            return SetData(csWriteNodeNo.LASER_RESET, bOn ? 1 : 0);
        }

        public int SetLaserOn(bool bOn)
        {
            return SetData(csWriteNodeNo.LASER_ON, bOn ? 1 : 0);
        }

        public int SetRequestLaser(bool bOn)
        {
            return SetData(csWriteNodeNo.REQUEST_LASER, bOn ? 1 : 0);
        }

        public int SetProgramStartDynamic(bool bOn)
        {
            return SetData(csWriteNodeNo.PSTART_DYN, bOn ? 1 : 0);
        }

        public int SetProgramStop(bool bOn)
        {
            return SetData(csWriteNodeNo.PROG_STOP, bOn ? 1 : 0);
        }

        public int SetProgramNo(int no)
        {
            return SetData(csWriteNodeNo.PROGRAM_NO, no);
        }
        #endregion
    }
}